googleformsubmitter 1.1.0 → 1.1.2

package/.github/workflows/publish-main.yml

@@ -0,0 +1,33 @@
+name: Publish main branch
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  id-token: write  # Required for OIDC https://docs.npmjs.com/trusted-publishers
+  contents: write  # Required for pushing tags
+
+jobs:
+  publish-main:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      # Ensure npm 11.5.1 or later is installed 
+      - run: npm install -g npm@latest
+      - name: Bump version
+        run: |
+          git config --global user.name "github-actions"
+          git config --global user.email "github-actions@github.com"
+          npm version patch
+      - name: Publish to NPM
+        run: npm publish --access public
+      - name: Commit and push
+        run: |
+          git push --follow-tags

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "googleformsubmitter",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "module": "src/index.ts",
   "main": "src/index.ts",
   "types": "src/index.ts",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iconicompany/googleformsubmitter.git"
+  },
   "scripts": {
     "test": "bun test",
     "lint": "oxlint",
     "validate": "tsgo --noEmit",
-    "create-form": "bun run ./tools/create-form.ts"
+    "create-form": "bun run ./tools/create-form.ts",
+    "introspect-form": "bun run ./tools/introspect-form.ts"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/google-form-submitter.test.ts

@@ -84,7 +84,7 @@ describe('GoogleFormSubmitter E2E Integration', () => {
 
     const formUrl = 'https://docs.google.com/forms/d/e/1FAIpQLSc1aiEAhxWCMSNjZ1asGDtXV_mT8vTiJRquiqfdjsoMkKT9tw/viewform';
     const credentialsPath = path.join(__dirname, '..', '..', 'imatching', '.data', 'credentials.json');
-    const tokenPath = path.join(__dirname, '..', '..', 'imatching', '.data', 'forms-auth.json');
+    const tokenPath = path.join(__dirname, '..', '..', 'imatching', '.data', 'gdrive-auth.json');
 
     submitter = new GoogleFormSubmitter({
       formUrl,
@@ -103,10 +103,10 @@ describe('GoogleFormSubmitter E2E Integration', () => {
   test('should dynamically resolve fields, upload file, and submit successfully', async () => {
     const candidateData = {
       requestId: '910',
-      fullName: 'Багманов Алмаз (Схема)',
+      fullName: 'Тестов Тест (Схема)',
       birthDate: '1996-07-03',
       grade: 'Middle',
-      location: 'Россия, Набережные Челны',
+      location: 'Россия, Москва',
       rate: '2000',
       nds: 'Нет',
       exitDate: 'через 21 дней',
@@ -114,7 +114,7 @@ describe('GoogleFormSubmitter E2E Integration', () => {
       inStaff: 'Да',
       cvFile: {
         buffer: Buffer.from('mock cv file contents for integration test'),
-        filename: 'cv_Багманов_Алмаз.docx',
+        filename: 'cv_Тестов_Тест.docx',
         mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
       },
       company: 'Iconicompany',
@@ -130,7 +130,7 @@ describe('GoogleFormSubmitter E2E Integration', () => {
     expect(result1.statusCode).toBe(200);
 
     console.log('\n--- SECOND RUN: Submitting instantly using cache ---');
-    candidateData.fullName = 'Багманов Алмаз (Схема-Кэш)';
+    candidateData.fullName = 'Тестов Тест (Схема-Кэш)';
     const result2 = await submitter.submit(candidateData);
     console.log('Result 2 Fields Submitted:', JSON.stringify(result2.fieldsSubmitted, null, 2));
 
@@ -138,3 +138,36 @@ describe('GoogleFormSubmitter E2E Integration', () => {
     expect(result2.statusCode).toBe(200);
   }, 45000); // 45 seconds timeout
 });
+
+describe('GoogleFormSubmitter.formatFields Unit Tests', () => {
+  test('should format simple text and choice fields correctly', () => {
+    const fields = {
+      'Номер запроса': '917',
+      'ФИО (полностью)': 'Иванов Иван Иванович',
+      'Грейд': 'middle'
+    };
+    const formatted = GoogleFormSubmitter.formatFields(fields);
+    expect(formatted).toContain('• Номер запроса: 917');
+    expect(formatted).toContain('• ФИО (полностью): Иванов Иван Иванович');
+    expect(formatted).toContain('• Грейд: middle');
+  });
+
+  test('should parse nested CV array and display only the filename', () => {
+    const fields = {
+      'CV (файл)': '[[["1Nrch5iArW-Gx-Vz4x9YlAM6FuhI5tEtt","cv_Иванов_Иван_Иванович.docx","application/vnd.openxmlformats-officedocument.wordprocessingml.document"]]]'
+    };
+    const formatted = GoogleFormSubmitter.formatFields(fields);
+    expect(formatted).toBe('• CV (файл): cv_Иванов_Иван_Иванович.docx');
+  });
+
+  test('should handle empty/null/undefined values gracefully', () => {
+    const fields = {
+      'Комментарий': null,
+      'Ближайший планируемый отпуск': undefined
+    };
+    const formatted = GoogleFormSubmitter.formatFields(fields);
+    expect(formatted).toContain('• Комментарий: —');
+    expect(formatted).toContain('• Ближайший планируемый отпуск: —');
+  });
+});
+

package/src/google-form-submitter.ts

@@ -337,4 +337,32 @@ export class GoogleFormSubmitter {
       await browser.close();
     }
   }
+
+  /**
+   * Helper to format submitted fields or raw payload into a clean, human-readable list.
+   */
+  public static formatFields(fields: Record<string, any>): string {
+    const formatValue = (val: any): string => {
+      if (typeof val === 'string') {
+        if (val.startsWith('[[[') && val.endsWith(']]]')) {
+          try {
+            const parsed = JSON.parse(val);
+            if (Array.isArray(parsed) && parsed[0]?.[0]?.[1]) {
+              return parsed[0][0][1];
+            }
+          } catch {}
+        }
+        return val;
+      }
+      if (val === null || val === undefined) {
+        return '—';
+      }
+      return String(val);
+    };
+
+    return Object.entries(fields)
+      .map(([key, val]) => `• ${key}: ${formatValue(val)}`)
+      .join('\n');
+  }
 }
+

package/tools/introspect-form.ts

@@ -0,0 +1,264 @@
+import { chromium } from 'playwright';
+import fs from 'fs/promises';
+import path from 'path';
+
+function toCamelCase(str: string): string {
+  // Map common Russian terms to standard project English keys
+  const translations: Record<string, string> = {
+    'фио': 'fullName',
+    'дата рождения': 'birthDate',
+    'грейд': 'grade',
+    'локация': 'location',
+    'рейт': 'rate',
+    'ндс': 'nds',
+    'когда кандидат': 'exitDate',
+    'отпуск': 'vacation',
+    'штате': 'inStaff',
+    'cv': 'cvFile',
+    'резюме': 'cvFile',
+    'компания': 'company',
+    'контакты': 'contacts',
+    'требованиям': 'checklist',
+    'комментарий': 'comment',
+    'номер запроса': 'requestId'
+  };
+
+  const lower = str.toLowerCase();
+  for (const [key, val] of Object.entries(translations)) {
+    if (lower.includes(key)) {
+      return val;
+    }
+  }
+
+  // Fallback to transliteration + camelCase
+  const clean = str
+    .replace(/[^a-zA-Zа-яА-Я0-9\s]/g, '')
+    .trim()
+    .replace(/\s+/g, ' ');
+
+  const ru: Record<string, string> = {
+    'а':'a', 'б':'b', 'в':'v', 'г':'g', 'д':'d', 'е':'e', 'ё':'yo', 'ж':'zh', 'з':'z', 'и':'i', 'й':'y', 'к':'k', 'л':'l', 'м':'m', 'н':'n', 'о':'o', 'п':'p', 'р':'r', 'с':'s', 'т':'t', 'у':'u', 'ф':'f', 'х':'h', 'ц':'ts', 'ч':'ch', 'ш':'sh', 'щ':'sch', 'ъ':'', 'ы':'y', 'ь':'', 'э':'e', 'ю':'yu', 'я':'ya',
+    'А':'A', 'Б':'B', 'В':'V', 'Г':'G', 'Д':'D', 'Е':'E', 'Ё':'Yo', 'Ж':'Zh', 'З':'Z', 'И':'I', 'Й':'Y', 'К':'K', 'Л':'L', 'М':'M', 'Н':'N', 'О':'O', 'П':'P', 'Р':'R', 'С':'S', 'Т':'T', 'У':'U', 'Ф':'F', 'Х':'H', 'Ц':'Ts', 'Ч':'Ch', 'Ш':'Sh', 'Щ':'Sch', 'Ъ':'', 'Ы':'Y', 'Ь':'', 'Э':'E', 'Ю':'Yu', 'Я':'Ya'
+  };
+  
+  let transliterated = '';
+  for (const char of clean) {
+    const replacement = ru[char] !== undefined ? ru[char] : char;
+    transliterated += replacement;
+  }
+
+  const words = transliterated.split(' ');
+  return words
+    .map((word, idx) => {
+      if (idx === 0) return word.toLowerCase();
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+    .join('');
+}
+
+async function main() {
+  const url = process.argv[2];
+  if (!url) {
+    console.error('Usage: bun run ./tools/introspect-form.ts <google-form-url>');
+    process.exit(1);
+  }
+
+  console.log(`🔍 Connecting to Google Form at: ${url}...`);
+
+  let browser;
+  try {
+    // Attempt connecting to local Lightpanda first
+    browser = await chromium.connectOverCDP(process.env.LIGHTPANDA_CDP_URL || 'ws://127.0.0.1:9222/', { timeout: 5000 });
+  } catch {
+    console.log('Lightpanda not found, falling back to local headless Chromium...');
+    browser = await chromium.launch({ headless: true });
+  }
+
+  const context = await browser.newContext();
+
+  // Load session cookies if GOOGLE_COOKIES_PATH is configured
+  const cookiesPath = process.env.GOOGLE_COOKIES_PATH;
+  if (cookiesPath) {
+    try {
+      const cookiesStr = await fs.readFile(cookiesPath, 'utf8');
+      const cookies = JSON.parse(cookiesStr);
+      await context.addCookies(cookies);
+      console.log(`[Introspect] Injected ${cookies.length} session cookies from ${cookiesPath}`);
+    } catch (e: any) {
+      console.warn(`[Introspect] Warning: Could not inject cookies: ${e.message}`);
+    }
+  }
+
+  const page = await context.newPage();
+  page.on('console', msg => console.log('PAGE LOG:', msg.text()));
+
+  try {
+    await page.goto(url);
+
+    // Wait for the form contents to load
+    await Promise.any([
+      page.locator('.Qr7Oae').first().waitFor({ state: 'attached', timeout: 15000 }),
+      page.waitForURL(/\/closedform/, { timeout: 15000 }).catch(() => {})
+    ]).catch(() => {});
+
+    if (page.url().includes('/closedform') || (await page.locator('form').count() === 0)) {
+      throw new Error('This Google Form is closed or redirecting to login. Make sure your session cookies are valid.');
+    }
+
+    // Inspect DOM
+    const questions = await page.evaluate(() => {
+      const g = globalThis as any;
+      const result: any[] = [];
+      const containers = g.document.querySelectorAll('.Qr7Oae');
+
+      containers.forEach((container: any) => {
+        const headerEl = container.querySelector('[role="heading"], .M7eMe, .HoRgec');
+        if (!headerEl) return;
+
+        let labelText = (headerEl.textContent || '').trim();
+        const isRequired = labelText.endsWith('*');
+        labelText = labelText.replace(/\s*\*$/, '').trim();
+
+        let type = 'text';
+        let choices: string[] = [];
+        let allowOther = false;
+
+        const paramsEl = container.hasAttribute('data-params') ? container : container.querySelector('[data-params]');
+        if (paramsEl) {
+          const dataParams = paramsEl.getAttribute('data-params');
+          try {
+            // Replace Google Forms prefix with '[' to restore the outer array opening bracket
+            const jsonText = dataParams.replace(/^%\.@\./, '[');
+            const parsed = JSON.parse(jsonText);
+            const questionInfo = parsed[0];
+            const typeId = questionInfo[3];
+            
+            if (typeId === 11 || typeId === 13) {
+              type = 'file';
+            } else if (typeId === 9) {
+              type = 'date';
+            } else if (typeId === 1) {
+              type = 'paragraph';
+            } else if (typeId === 2 || typeId === 3 || typeId === 4) {
+              type = 'choice';
+              const choicesArray = questionInfo[4]?.[0]?.[1];
+              if (choicesArray && Array.isArray(choicesArray)) {
+                choices = choicesArray.map((c: any) => c[0]).filter((val) => val !== null && val !== undefined && val !== '');
+              }
+              allowOther = !!questionInfo[4]?.[0]?.[2];
+            }
+          } catch (e: any) {
+            console.error('PAGE LOG [Parser Error]:', e.message, 'Data:', dataParams);
+            // Fallback to legacy DOM checks if parse fails
+            if (container.querySelector('[type="file"]') || container.querySelector('[data-params*="file"]')) {
+              type = 'file';
+            } else if (container.querySelector('input[type="date"]') || container.querySelector('[data-params*="[[3,"]')) {
+              type = 'date';
+            } else if (container.querySelector('[role="radio"], [role="checkbox"], select, .SGZTVe')) {
+              type = 'choice';
+              const optionEls = container.querySelectorAll('[role="radio"] + *, [role="checkbox"] + *, option, .fwW70c, .text');
+              optionEls.forEach((opt: any) => {
+                const text = (opt.textContent || '').trim();
+                if (text && !text.toLowerCase().includes('другое') && !text.toLowerCase().includes('other')) {
+                  choices.push(text);
+                }
+              });
+            } else if (container.querySelector('textarea')) {
+              type = 'paragraph';
+            }
+          }
+        } else {
+          console.warn('PAGE LOG: paramsEl not found for label:', labelText);
+        }
+
+        result.push({
+          label: labelText,
+          type,
+          required: isRequired,
+          choices: choices.length > 0 ? [...new Set(choices)] : undefined,
+          allowOther: allowOther || undefined
+        });
+      });
+
+      return result;
+    });
+
+    console.log(`\n🎉 Introspected ${questions.length} fields successfully. Generating schema objects...\n`);
+
+    const jsonProperties: Record<string, any> = {};
+    const jsonRequired: string[] = [];
+    const mappingSchema: Record<string, any> = {};
+
+    for (const q of questions) {
+      const key = toCamelCase(q.label);
+
+      // JSON Schema building
+      if (q.type === 'file') {
+        jsonProperties[key] = {
+          type: 'object',
+          properties: {
+            fileId: { type: 'string' },
+            buffer: { type: 'object' },
+            filename: { type: 'string' },
+            mimeType: { type: 'string' }
+          },
+          required: ['filename', 'mimeType']
+        };
+      } else if (q.type === 'choice') {
+        jsonProperties[key] = {
+          type: 'string'
+        };
+        if (q.choices && q.choices.length > 0) {
+          jsonProperties[key].enum = q.choices;
+        }
+      } else {
+        jsonProperties[key] = {
+          type: 'string'
+        };
+        if (q.type === 'date') {
+          jsonProperties[key].pattern = '^\\d{4}-\\d{2}-\\d{2}$';
+        }
+      }
+
+      if (q.required) {
+        jsonRequired.push(key);
+      }
+
+      // Mapping Schema building
+      mappingSchema[key] = {
+        label: q.label,
+        type: q.type
+      };
+      if (q.type === 'choice') {
+        mappingSchema[key].options = {
+          choices: q.choices || []
+        };
+        if (q.allowOther) {
+          mappingSchema[key].options.allowOther = true;
+        }
+      }
+    }
+
+    const finalJsonSchema = {
+      type: 'object',
+      properties: jsonProperties,
+      required: jsonRequired
+    };
+
+    // Print TypeScript output
+    console.log('// ==========================================');
+    console.log('// GENERATED SCHEMAS FOR GOOGLE FORM');
+    console.log('// ==========================================');
+    console.log('\nexport const JSON_SCHEMA = ' + JSON.stringify(finalJsonSchema, null, 2) + ';\n');
+    console.log('export const MAPPING_SCHEMA = ' + JSON.stringify(mappingSchema, null, 2) + ';\n');
+
+  } finally {
+    await context.close();
+    await browser.close();
+  }
+}
+
+main().catch((err) => {
+  console.error('❌ Error during form introspection:', err.message);
+  process.exit(1);
+});

package/.data/form-cache-1FAIpQLSc1aiEAhxWCMSNjZ1asGDtXV_mT8vTiJRquiqfdjsoMkKT9tw.json

@@ -1,16 +0,0 @@
-{
-  "requestId": "1876174487",
-  "fullName": "1192130047",
-  "birthDate": "1354328376",
-  "grade": "1867801269",
-  "location": "1504377681",
-  "rate": "282114114",
-  "nds": "1347448341",
-  "exitDate": "1161802420",
-  "vacation": "1977793041",
-  "inStaff": "447126466",
-  "cvFile": "1595274093",
-  "company": "553187985",
-  "checklist": "1954006978",
-  "comment": "998553124"
-}

package/CLAUDE.md

@@ -1,106 +0,0 @@
-
-Default to using Bun instead of Node.js.
-
-- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
-- Use `bun test` instead of `jest` or `vitest`
-- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
-- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
-- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
-- Use `bunx <package> <command>` instead of `npx <package> <command>`
-- Bun automatically loads .env, so don't use dotenv.
-
-## APIs
-
-- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
-- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
-- `Bun.redis` for Redis. Don't use `ioredis`.
-- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
-- `WebSocket` is built-in. Don't use `ws`.
-- Prefer `Bun.file` over `node:fs`'s readFile/writeFile
-- Bun.$`ls` instead of execa.
-
-## Testing
-
-Use `bun test` to run tests.
-
-```ts#index.test.ts
-import { test, expect } from "bun:test";
-
-test("hello world", () => {
-  expect(1).toBe(1);
-});
-```
-
-## Frontend
-
-Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
-
-Server:
-
-```ts#index.ts
-import index from "./index.html"
-
-Bun.serve({
-  routes: {
-    "/": index,
-    "/api/users/:id": {
-      GET: (req) => {
-        return new Response(JSON.stringify({ id: req.params.id }));
-      },
-    },
-  },
-  // optional websocket support
-  websocket: {
-    open: (ws) => {
-      ws.send("Hello, world!");
-    },
-    message: (ws, message) => {
-      ws.send(message);
-    },
-    close: (ws) => {
-      // handle close
-    }
-  },
-  development: {
-    hmr: true,
-    console: true,
-  }
-})
-```
-
-HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
-
-```html#index.html
-<html>
-  <body>
-    <h1>Hello, world!</h1>
-    <script type="module" src="./frontend.tsx"></script>
-  </body>
-</html>
-```
-
-With the following `frontend.tsx`:
-
-```tsx#frontend.tsx
-import React from "react";
-import { createRoot } from "react-dom/client";
-
-// import .css files directly and it works
-import './index.css';
-
-const root = createRoot(document.body);
-
-export default function Frontend() {
-  return <h1>Hello, world!</h1>;
-}
-
-root.render(<Frontend />);
-```
-
-Then, run index.ts
-
-```sh
-bun --hot ./index.ts
-```
-
-For more information, read the Bun API docs in `node_modules/bun-types/docs/**.mdx`.