offbyt 1.0.0

package/core/ir/buildIR.js

@@ -0,0 +1,83 @@
+import { createField, createIR, createResource } from './IRTypes.js';
+
+function singularize(name) {
+  return name.toLowerCase().replace(/ies$/, 'y').replace(/s$/, '');
+}
+
+function extractResourceFromRoute(route) {
+  if (!route) return null;
+  const cleaned = route.split('?')[0];
+  const match = cleaned.match(/\/api\/(?:v\d+\/)?([^/]+)/i);
+  if (match?.[1]) return singularize(match[1]);
+
+  const fallback = cleaned.replace(/^\/+/, '').split('/')[0];
+  return fallback ? singularize(fallback) : null;
+}
+
+function normalizeRoute(route = '') {
+  return route.split('?')[0].trim().replace(/\/+$/, '').toLowerCase();
+}
+
+function isHealthProbeCall(call, resourceName) {
+  if (resourceName !== 'health') return false;
+
+  const method = (call.method || 'GET').toUpperCase();
+  if (method !== 'GET') return false;
+
+  const route = normalizeRoute(call.route || '');
+  return route === '/health' || route === `/api/health`;
+}
+
+export function buildIRFromDetections(apiCalls = [], forms = []) {
+  const resourcesMap = new Map();
+
+  for (const call of apiCalls) {
+    const resourceName = extractResourceFromRoute(call.route);
+    if (!resourceName || resourceName === 'api') continue;
+    if (isHealthProbeCall(call, resourceName)) continue;
+
+    if (!resourcesMap.has(resourceName)) {
+      resourcesMap.set(resourceName, {
+        name: resourceName,
+        path: `/${resourceName}s`,
+        methodSet: new Set(),
+        fieldSet: new Set()
+      });
+    }
+
+    const resource = resourcesMap.get(resourceName);
+    resource.methodSet.add((call.method || 'GET').toUpperCase());
+
+    for (const field of call.fields || []) {
+      if (field) resource.fieldSet.add(field);
+    }
+  }
+
+  for (const form of forms) {
+    for (const field of form.fields || []) {
+      if (!field) continue;
+      for (const resource of resourcesMap.values()) {
+        resource.fieldSet.add(field);
+      }
+    }
+  }
+
+  const resources = Array.from(resourcesMap.values()).map((resource) => {
+    const fields = Array.from(resource.fieldSet).map((fieldName) => createField(fieldName));
+    return createResource({
+      name: resource.name,
+      path: resource.path,
+      fields,
+      methods: Array.from(resource.methodSet)
+    });
+  });
+
+  return createIR({
+    resources,
+    relations: [],
+    auth: { enabled: false },
+    database: 'mongodb'
+  });
+}
+
+export default buildIRFromDetections;

package/core/parser/parseJS.js

@@ -0,0 +1,26 @@
+import { parse } from '@babel/parser';
+
+export function parseJS(code, sourceFilename = 'unknown.js') {
+  try {
+    return parse(code, {
+      sourceType: 'unambiguous',
+      sourceFilename,
+      errorRecovery: true,
+      plugins: [
+        'jsx',
+        'classProperties',
+        'classPrivateProperties',
+        'classPrivateMethods',
+        'objectRestSpread',
+        'optionalChaining',
+        'nullishCoalescingOperator',
+        'dynamicImport',
+        'topLevelAwait'
+      ]
+    });
+  } catch {
+    return null;
+  }
+}
+
+export default parseJS;

package/core/parser/parseTS.js

@@ -0,0 +1,27 @@
+import { parse } from '@babel/parser';
+
+export function parseTS(code, sourceFilename = 'unknown.ts') {
+  try {
+    return parse(code, {
+      sourceType: 'unambiguous',
+      sourceFilename,
+      errorRecovery: true,
+      plugins: [
+        'typescript',
+        'jsx',
+        'classProperties',
+        'classPrivateProperties',
+        'classPrivateMethods',
+        'objectRestSpread',
+        'optionalChaining',
+        'nullishCoalescingOperator',
+        'dynamicImport',
+        'topLevelAwait'
+      ]
+    });
+  } catch {
+    return null;
+  }
+}
+
+export default parseTS;

package/core/rules/relationRules.js

@@ -0,0 +1,38 @@
+function normalizeResourceName(name) {
+  return name.toLowerCase().replace(/ies$/, 'y').replace(/s$/, '');
+}
+
+function pascalCase(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+export function applyRelationRules(ir) {
+  const resources = ir.resources || [];
+  const resourceNames = new Set(resources.map((r) => normalizeResourceName(r.name)));
+  const relationSet = new Set();
+  const relations = [...(ir.relations || [])];
+
+  for (const resource of resources) {
+    for (const field of resource.fields || []) {
+      const match = field.name.match(/^(\w+)Id$/i);
+      if (!match) continue;
+
+      const target = normalizeResourceName(match[1]);
+      if (!resourceNames.has(target)) continue;
+
+      field.type = 'ObjectId';
+      field.ref = pascalCase(target);
+
+      const key = `${resource.name}->${target}`;
+      if (!relationSet.has(key)) {
+        relationSet.add(key);
+        relations.push({ from: pascalCase(resource.name), to: pascalCase(target), type: 'many-to-one' });
+      }
+    }
+  }
+
+  ir.relations = relations;
+  return ir;
+}
+
+export default applyRelationRules;

package/core/rules/resourceRules.js

@@ -0,0 +1,32 @@
+import { applySchemaInference } from './schemaInference.js';
+import { applyRelationRules } from './relationRules.js';
+
+const CRUD_METHODS = ['GET', 'POST', 'PUT', 'DELETE'];
+
+function expandCrudMethods(methods = []) {
+  const set = new Set(methods.map((m) => m.toUpperCase()));
+
+  if (set.has('POST') || set.has('PUT') || set.has('PATCH') || set.has('DELETE')) {
+    for (const method of CRUD_METHODS) set.add(method);
+  }
+
+  return Array.from(set).sort();
+}
+
+export function applyResourceRules(ir) {
+  ir.resources = (ir.resources || []).map((resource) => ({
+    ...resource,
+    methods: expandCrudMethods(resource.methods)
+  }));
+  return ir;
+}
+
+export function applyRuleEngine(ir) {
+  let next = structuredClone(ir);
+  next = applyResourceRules(next);
+  next = applySchemaInference(next);
+  next = applyRelationRules(next);
+  return next;
+}
+
+export default applyRuleEngine;

package/core/rules/schemaInference.js

@@ -0,0 +1,26 @@
+const FIELD_TYPE_RULES = [
+  { pattern: /email/i, type: 'String' },
+  { pattern: /price|amount|cost|total|quantity|count|age/i, type: 'Number' },
+  { pattern: /date|time|at$/i, type: 'Date' },
+  { pattern: /^is[A-Z]|^has[A-Z]|^can[A-Z]|active|enabled|completed|verified/i, type: 'Boolean' },
+  { pattern: /id$/i, type: 'ObjectId' }
+];
+
+export function inferFieldType(fieldName) {
+  const matched = FIELD_TYPE_RULES.find((rule) => rule.pattern.test(fieldName));
+  return matched ? matched.type : 'String';
+}
+
+export function applySchemaInference(ir) {
+  ir.resources = (ir.resources || []).map((resource) => {
+    resource.fields = (resource.fields || []).map((field) => ({
+      ...field,
+      type: field.type && field.type !== 'String' ? field.type : inferFieldType(field.name)
+    }));
+    return resource;
+  });
+
+  return ir;
+}
+
+export default applySchemaInference;

package/core/scanner/scanProject.js

@@ -0,0 +1,58 @@
+import fs from 'fs';
+import path from 'path';
+import fg from 'fast-glob';
+
+const DEFAULT_PATTERNS = [
+  'src/**/*.{html,js,jsx,ts,tsx}',
+  'app/**/*.{html,js,jsx,ts,tsx}',
+  'pages/**/*.{html,js,jsx,ts,tsx}',
+  'components/**/*.{html,js,jsx,ts,tsx}',
+  'services/**/*.{html,js,jsx,ts,tsx}',
+  'frontend/**/*.{html,js,jsx,ts,tsx}',
+  'client/**/*.{html,js,jsx,ts,tsx}',
+  'public/**/*.{html,js,jsx,ts,tsx}',
+  '*.{html,js,jsx,ts,tsx}'
+];
+
+const DEFAULT_IGNORE = [
+  '**/node_modules/**',
+  '**/.git/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/.next/**',
+  '**/coverage/**'
+];
+
+function detectLanguage(ext) {
+  if (ext === '.ts' || ext === '.tsx') return 'ts';
+  if (ext === '.js' || ext === '.jsx') return 'js';
+  if (ext === '.html') return 'html';
+  return 'unknown';
+}
+
+export function scanProject(projectPath, options = {}) {
+  const patterns = options.patterns || DEFAULT_PATTERNS;
+  const ignore = options.ignore || DEFAULT_IGNORE;
+
+  const fullPaths = fg.sync(patterns, {
+    cwd: projectPath,
+    absolute: true,
+    onlyFiles: true,
+    unique: true,
+    ignore
+  });
+
+  return fullPaths.map((fullPath) => {
+    const ext = path.extname(fullPath).toLowerCase();
+    const content = fs.readFileSync(fullPath, 'utf8');
+    return {
+      fullPath,
+      relativePath: path.relative(projectPath, fullPath).replace(/\\/g, '/'),
+      extension: ext,
+      language: detectLanguage(ext),
+      content
+    };
+  });
+}
+
+export default scanProject;

package/deploy/cloudflare.js

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import path from 'path';
+import { deployWithCommand, runCommandCapture, detectBuildOutputDirectory } from './utils.js';
+
+async function checkWranglerLogin() {
+  try {
+    const result = await runCommandCapture({
+      command: 'wrangler',
+      args: ['whoami'],
+      cwd: process.cwd(),
+      streamOutput: false
+    });
+    return !result.stdout.toLowerCase().includes('not logged in');
+  } catch {
+    return false;
+  }
+}
+
+export async function deployToCloudflare(frontendPath, options = {}) {
+  const buildDir = options.buildDir || detectBuildOutputDirectory(frontendPath) || 'dist';
+  const buildPath = path.join(frontendPath, buildDir);
+
+  return deployWithCommand({
+    providerName: 'Cloudflare Pages',
+    command: 'wrangler',
+    packageName: 'wrangler',
+    args: ['pages', 'deploy', buildDir],
+    cwd: frontendPath,
+    urlHints: ['pages.dev'],
+    loginCheck: checkWranglerLogin,
+    loginCommand: { command: 'wrangler', args: ['login'] },
+    successLabel: 'Frontend deployed on Cloudflare Pages',
+    preflight: async () => {
+      if (!fs.existsSync(buildPath)) {
+        throw new Error(
+          `Build output folder "${buildDir}" was not found in ${frontendPath}. Run your frontend build first.`
+        );
+      }
+    }
+  });
+}

package/deploy/cloudflareWorker.js

@@ -0,0 +1,122 @@
+import fs from 'fs';
+import path from 'path';
+import { deployWithCommand, runCommandCapture } from './utils.js';
+
+function sanitizeProjectName(rawValue, fallback = 'offbyt-api') {
+  const normalized = String(rawValue || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-+|-+$/g, '');
+
+  const base = normalized || fallback;
+  return base.slice(0, 58);
+}
+
+async function checkWranglerLogin() {
+  try {
+    const result = await runCommandCapture({
+      command: 'wrangler',
+      args: ['whoami'],
+      cwd: process.cwd(),
+      streamOutput: false
+    });
+
+    const output = `${result.stdout}\n${result.stderr}`.toLowerCase();
+    return !output.includes('not logged in') && !output.includes('authentication') && !output.includes('login');
+  } catch {
+    return false;
+  }
+}
+
+function ensurePagesBackendScaffold(backendPath, projectName) {
+  const deployDir = path.join(backendPath, '.offbyt-cloudflare-pages');
+  const workerFile = path.join(deployDir, '_worker.js');
+  const indexFile = path.join(deployDir, 'index.html');
+  const wranglerConfig = path.join(deployDir, 'wrangler.toml');
+
+  fs.mkdirSync(deployDir, { recursive: true });
+
+  if (!fs.existsSync(workerFile)) {
+    const workerTemplate = `const json = (status, body) => new Response(JSON.stringify(body), {\n  status,\n  headers: { 'content-type': 'application/json; charset=utf-8' }\n});\n\nexport default {\n  async fetch(request) {\n    const url = new URL(request.url);\n\n    if (request.method === 'GET' && url.pathname === '/') {\n      return json(200, {\n        success: true,\n        message: 'offbyt Cloudflare Pages backend is running'\n      });\n    }\n\n    if (request.method === 'GET' && url.pathname === '/health') {\n      return json(200, {\n        status: 'ok',\n        platform: 'cloudflare-pages',\n        timestamp: new Date().toISOString()\n      });\n    }\n\n    if (request.method === 'GET' && url.pathname === '/api/ping') {\n      return json(200, { success: true, data: 'pong' });\n    }\n\n    return json(404, { success: false, message: 'Route not found' });\n  }\n};\n`;
+
+    fs.writeFileSync(workerFile, workerTemplate, 'utf8');
+  }
+
+  if (!fs.existsSync(indexFile)) {
+    const html = '<!doctype html><html><head><meta charset="utf-8"><title>offbyt API</title></head><body><h1>offbyt API</h1><p>Project: ' + projectName + '</p></body></html>\n';
+    fs.writeFileSync(indexFile, html, 'utf8');
+  }
+
+  const wranglerToml = [
+    `name = "${projectName}"`,
+    'pages_build_output_dir = "."',
+    'compatibility_date = "2026-03-06"'
+  ].join('\n');
+
+  fs.writeFileSync(wranglerConfig, `${wranglerToml}\n`, 'utf8');
+
+  return { deployDir };
+}
+
+async function ensurePagesProject(projectName, cwd) {
+  try {
+    const listResult = await runCommandCapture({
+      command: 'wrangler',
+      args: ['pages', 'project', 'list'],
+      cwd,
+      streamOutput: false
+    });
+
+    const listOutput = `${listResult.stdout}\n${listResult.stderr}`.toLowerCase();
+    if (listOutput.includes(projectName.toLowerCase())) {
+      return;
+    }
+  } catch {
+    // Fall through and try project creation directly.
+  }
+
+  try {
+    await runCommandCapture({
+      command: 'wrangler',
+      args: ['pages', 'project', 'create', projectName, '--production-branch', 'main'],
+      cwd,
+      streamOutput: true
+    });
+  } catch (error) {
+    const message = String(error.message || '').toLowerCase();
+    const alreadyExists = message.includes('already exists') || message.includes('already in use');
+
+    if (!alreadyExists) {
+      throw error;
+    }
+  }
+}
+
+export async function deployToCloudflareWorker(backendPath, options = {}) {
+  let projectName = '';
+  let deployDir = path.join(backendPath, '.offbyt-cloudflare-pages');
+
+  const preflight = async () => {
+    projectName = sanitizeProjectName(options.projectName || path.basename(backendPath), 'offbyt-api');
+    const setup = ensurePagesBackendScaffold(backendPath, projectName);
+    deployDir = setup.deployDir;
+    await ensurePagesProject(projectName, deployDir);
+  };
+
+  return deployWithCommand({
+    providerName: 'Cloudflare Pages',
+    command: 'wrangler',
+    packageName: 'wrangler',
+    args: () => ['pages', 'deploy', '.', '--project-name', projectName, '--commit-dirty=true'],
+    cwd: deployDir || backendPath,
+    urlHints: ['pages.dev'],
+    loginCheck: checkWranglerLogin,
+    loginCommand: { command: 'wrangler', args: ['login'] },
+    commandNeedsTty: true,
+    preflight,
+    postDeploy: async () => `https://${projectName}.pages.dev`,
+    successLabel: 'Backend deployed on Cloudflare Pages'
+  });
+}
+

package/deploy/connect.js

@@ -0,0 +1,198 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { detectLocalBackendUrl, readPackageJsonSafe } from './utils.js';
+
+const SOURCE_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.html']);
+const IGNORE_FOLDERS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo', 'coverage', 'backend']);
+
+export function autoConnectDeployment({ projectPath, frontendPath, backendUrl }) {
+  const packageJson = readPackageJsonSafe(frontendPath) || {};
+  const isVite = detectVite(frontendPath, packageJson);
+  const apiVar = isVite ? 'VITE_API_URL' : 'REACT_APP_API_URL';
+  const envReference = isVite ? 'import.meta.env.VITE_API_URL' : 'process.env.REACT_APP_API_URL';
+  const localBackendUrl = detectLocalBackendUrl(projectPath);
+
+  const envFilesUpdated = [];
+  envFilesUpdated.push(...upsertEnvFile(path.join(frontendPath, '.env.development'), [
+    [apiVar, localBackendUrl],
+    ['BACKEND_URL_LOCAL', localBackendUrl]
+  ]));
+
+  envFilesUpdated.push(...upsertEnvFile(path.join(frontendPath, '.env.production'), [
+    [apiVar, backendUrl],
+    ['BACKEND_URL', backendUrl]
+  ]));
+
+  envFilesUpdated.push(...upsertEnvFile(path.join(frontendPath, '.env'), [
+    [apiVar, localBackendUrl]
+  ]));
+
+  const sourceFiles = collectFrontendSourceFiles(frontendPath);
+
+  let updatedFileCount = 0;
+
+  for (const filePath of sourceFiles) {
+    const original = fs.readFileSync(filePath, 'utf8');
+    const rewritten = rewriteApiReferences(original, envReference, backendUrl);
+
+    if (rewritten !== original) {
+      fs.writeFileSync(filePath, rewritten, 'utf8');
+      updatedFileCount += 1;
+    }
+  }
+
+  console.log(chalk.cyan('\nConnecting frontend with backend...\n'));
+  console.log(chalk.white('  Local API URL:'), chalk.gray(localBackendUrl));
+  console.log(chalk.white('  Production API URL:'), chalk.gray(backendUrl));
+  console.log(chalk.white('  Env strategy:'), chalk.gray(`${apiVar} in .env.development + .env.production`));
+
+  return {
+    isVite,
+    apiVar,
+    localBackendUrl,
+    updatedFileCount,
+    envFilesUpdated: [...new Set(envFilesUpdated)]
+  };
+}
+
+function rewriteApiReferences(content, envReference, backendUrl) {
+  const envTemplatePrefix = `\${${envReference}}`;
+  const backendOrigin = safeOrigin(backendUrl);
+
+  let updated = content;
+
+  // Replace relative /api URLs with environment-based base URL.
+  updated = updated.replace(/(["'`])(\/api(?:\/[^"'`\n]*)?)\1/g, (_match, _quote, apiPath) => {
+    return `\`${envTemplatePrefix}${apiPath}\``;
+  });
+
+  // Replace localhost absolute API URLs.
+  updated = updated.replace(
+    /(["'`])https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d+(\/api(?:\/[^"'`\n]*)?)\1/g,
+    (_match, _quote, apiPath) => {
+      return `\`${envTemplatePrefix}${apiPath}\``;
+    }
+  );
+
+  // Replace previously deployed absolute API URLs when redeploying to a new host.
+  if (backendOrigin) {
+    const escapedOrigin = escapeRegex(backendOrigin);
+    const absoluteApiRegex = new RegExp(
+      "([\"'`])" + escapedOrigin + "(\\/api(?:\\/[^\"'`\\n]*)?)\\1",
+      'g'
+    );
+    updated = updated.replace(absoluteApiRegex, (_match, _quote, apiPath) => {
+      return `\`${envTemplatePrefix}${apiPath}\``;
+    });
+  }
+
+  // Replace hardcoded API base URL constants (without /api suffix).
+  updated = updated.replace(
+    /(["'`])https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d+\1/g,
+    envReference
+  );
+
+  return updated;
+}
+
+function detectVite(frontendPath, packageJson) {
+  const deps = packageJson.dependencies || {};
+  const devDeps = packageJson.devDependencies || {};
+
+  if (deps.vite || devDeps.vite) {
+    return true;
+  }
+
+  const viteConfigFiles = ['vite.config.js', 'vite.config.ts', 'vite.config.mjs', 'vite.config.cjs'];
+  return viteConfigFiles.some((file) => fs.existsSync(path.join(frontendPath, file)));
+}
+
+function collectFrontendSourceFiles(frontendPath) {
+  const candidates = [
+    path.join(frontendPath, 'src'),
+    path.join(frontendPath, 'app'),
+    path.join(frontendPath, 'pages'),
+    path.join(frontendPath, 'components')
+  ];
+
+  if (candidates.every((candidate) => !fs.existsSync(candidate))) {
+    candidates.push(frontendPath);
+  }
+
+  const files = [];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      walk(candidate, files);
+    }
+  }
+
+  return [...new Set(files)];
+}
+
+function walk(currentPath, files) {
+  const stat = fs.statSync(currentPath);
+
+  if (stat.isFile()) {
+    const extension = path.extname(currentPath).toLowerCase();
+    if (SOURCE_EXTENSIONS.has(extension)) {
+      files.push(currentPath);
+    }
+    return;
+  }
+
+  const folderName = path.basename(currentPath).toLowerCase();
+  if (IGNORE_FOLDERS.has(folderName)) {
+    return;
+  }
+
+  const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+  for (const entry of entries) {
+    walk(path.join(currentPath, entry.name), files);
+  }
+}
+
+function upsertEnvFile(filePath, entries) {
+  const updated = [];
+
+  let content = '';
+  if (fs.existsSync(filePath)) {
+    content = fs.readFileSync(filePath, 'utf8');
+  }
+
+  const lines = content === '' ? [] : content.split(/\r?\n/);
+
+  for (const [key, value] of entries) {
+    const serialized = `${key}=${value}`;
+    const index = lines.findIndex((line) => line.startsWith(`${key}=`));
+
+    if (index >= 0) {
+      lines[index] = serialized;
+    } else {
+      lines.push(serialized);
+    }
+
+    updated.push(filePath);
+  }
+
+  const nextContent = `${lines.filter((line, idx, arr) => {
+    if (line.trim() !== '') return true;
+    return idx !== arr.length - 1;
+  }).join('\n')}\n`;
+
+  fs.writeFileSync(filePath, nextContent, 'utf8');
+  return updated;
+}
+
+function safeOrigin(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+
+function escapeRegex(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}