Connect NetSuite Records to Ironclad Workflows and Sync Contracts

/**
 * @NApiVersion 2.1
 * @NScriptType Restlet
 * @description Handles file uploads with strict record attachment and atomic rollback.
 */
define(['N/file', 'N/record', 'N/search', 'N/error', 'N/log'], (file, record, search, error, log) => { // Fixed =>
  
  const getNSFileType = (fileName) => { // Fixed =>
    if (!fileName || fileName.indexOf('.') === -1) {
      throw error.create({
        name: 'INVALID_FILE_NAME',
        message: 'File name must include a valid extension.',
        notifyOff: true,
      });
    }
    const ext = fileName.split('.').pop().toLowerCase();
    const typeMap = {
      pdf: file.Type.PDF,
      doc: file.Type.WORD,
      docx: file.Type.WORD,
      rtf: file.Type.RTF,
      txt: file.Type.PLAINTEXT,
      xls: file.Type.EXCEL,
      xlsx: file.Type.EXCEL,
      xlsm: file.Type.EXCEL,
      csv: file.Type.CSV,
      ppt: file.Type.POWERPOINT,
      pptx: file.Type.POWERPOINT,
      jpg: file.Type.JPGIMAGE,
      jpeg: file.Type.JPGIMAGE,
      png: file.Type.PNGIMAGE,
      gif: file.Type.GIFIMAGE,
      tif: file.Type.TIFFIMAGE,
      tiff: file.Type.TIFFIMAGE,
      xml: file.Type.XMLDOC,
      htm: file.Type.HTMLDOC,
      html: file.Type.HTMLDOC,
      eml: file.Type.MESSAGERFC,
      msg: file.Type.AUTODETECT,
      asice: file.Type.AUTODETECT,
      adoc: file.Type.AUTODETECT,
      bdoc: file.Type.AUTODETECT,
      ddoc: file.Type.AUTODETECT,
      edoc: file.Type.AUTODETECT,
    };
    if (!typeMap[ext]) {
      throw error.create({
        name: 'INVALID_FILE_TYPE',
        message: `File type .${ext} is not supported.`,
        notifyOff: true,
      });
    }
    return typeMap[ext];
  };

  const checkFileExists = (fileName, folderId) => { // Fixed =>
    const fileSearch = search.create({
      type: 'file',
      filters: [['name', 'is', fileName], 'AND', ['folder', 'anyof', folderId]],
    });
    return fileSearch.runPaged().count > 0; // Fixed: Added '>' operator
  };

  const isValidRecord = (recType, recId) => { // Fixed =>
    try {
      if (!recType || !recId) return false;
      const lookup = search.lookupFields({
        type: recType,
        id: recId,
        columns: ['internalid'],
      });
      return !!lookup.internalid;
    } catch (e) {
      return false;
    }
  };

  return {
    post: (request) => { // Fixed =>
      log.debug({ title: 'Incoming Request', details: request });

      // 1. Input Validation
      if (!request.name || !request.folderId || !request.content || !request.recordType || !request.recordId) {
        throw error.create({
          name: 'MISSING_REQUIRED_FIELDS',
          message: 'Payload must contain: name, folderId, content, recordType, and recordId',
          notifyOff: true,
        });
      }

      const fileName = request.name.trim();
      const folderId = parseInt(request.folderId);
      const { recordType, recordId } = request;

      // 2. Record Validation
      if (!isValidRecord(recordType, recordId)) {
        throw error.create({
          name: 'INVALID_RECORD_TARGET',
          message: `Target record (${recordType}:${recordId}) does not exist.`,
          notifyOff: true,
        });
      }

      // 3. Duplicate Prevention
      if (checkFileExists(fileName, folderId)) {
        throw error.create({
          name: 'FILE_ALREADY_EXISTS',
          message: `File ${fileName} already exists in folder ${folderId}.`,
          notifyOff: true,
        });
      }

      // TRANSACTIONAL OPERATIONS (Rollback Active)
      let fileId = null;

      try {
        // 4. File Creation
        const fileObj = file.create({
          name: fileName,
          fileType: getNSFileType(fileName),
          contents: request.content,
          folder: folderId,
          encoding: file.Encoding.BASE64,
          isOnline: true,
        });

        fileId = fileObj.save();
        log.audit({ title: 'File Saved', details: `File ID: ${fileId} created.` });

        // 5. Attach to Record
        record.attach({
          record: { type: 'file', id: fileId },
          to: { type: recordType, id: recordId },
        });

        return {
          status: 'success',
          fileId: fileId,
          fileName: fileName,
          attachedToRecordType: recordType,
          attachedToRecordId: recordId,
        };
      } catch (e) {
        log.error({ title: 'Transaction Failed', details: e });

        // ROLLBACK: Delete the file if it was created but attachment failed
        if (fileId) {
          try {
            file.delete({ id: fileId });
            log.audit({ title: 'Rollback Executed', details: `Deleted orphan file ${fileId}` });
          } catch (delErr) {
            log.emergency({ title: 'Rollback Failed', details: delErr });
          }
        }

        throw error.create({
          name: e.name || 'UPLOAD_FAILED',
          message: e.message || 'An unexpected error occurred.',
          notifyOff: true,
        });
      }
    },
  };
});