Namespaces and Filters

export default function (listener) {
  // Customer Portal - External customer data import
  listener.namespace('space:customer-portal', (customerListener) => {
    customerListener.use(configureCustomerPortalSpace);
    customerListener.use(configureGuidedSetup);
    customerListener.use(validateCustomerData);
  });

  // Internal Tools - Admin and operations
  listener.namespace('space:internal-tools', (internalListener) => {
    internalListener.use(configureInternalToolsSpace);
    internalListener.use(validateAdvancedRules);
    internalListener.use(applyBusinessLogic);
  });

  // Partner Integration - B2B data exchange
  listener.namespace('space:partner-integration', (partnerListener) => {
    partnerListener.use(configurePartnerIntegrationSpace);
    partnerListener.use(processAutomatically);
    partnerListener.use(syncPartnerData);
  });
}

const templateSpace = await api.spaces.create({
  name: "Template Manager",
  namespace: "templates", // Simple string identifier
  // ...space configuration
});

// Set namespace based on space name patterns
listener.on("job:ready", { job: "space:configure" }, async (event) => {
  const { jobId, spaceId } = event.context;

  try {
    await api.jobs.ack(jobId, { info: "Configuring space with namespace" });

    // Get Space details to determine namespace
    const space = await api.spaces.get(spaceId);
    
    // Route spaces to different namespaces based on naming conventions
    let namespace;
    if (space.data.name.toLowerCase().endsWith('portal')) {
      namespace = 'customer-portal';
    } else if (space.data.name.toLowerCase().endsWith('admin')) {
      namespace = 'internal-tools';
    } else if (space.data.name.toLowerCase().endsWith('partner')) {
      namespace = 'partner-integration';
    } else {
      namespace = 'general'; // Default namespace
    }
    
    await api.spaces.update(spaceId, {
      namespace: namespace,
    });

    // ...create workbooks, sheets, documents

    await api.jobs.complete(jobId, {
      outcome: { message: `Space configured with namespace: ${namespace}` }
    });
  } catch (error) {
    console.error(error);
    await api.jobs.fail(jobId, { 
      outcome: { message: `Configuration failed: ${error.message}` }
    });
  }
});

  // Listen to Events from customer portal Spaces
  listener.namespace('space:customer-portal', (customerPortalListener) => {
    customerPortalListener.use(applyCustomerBranding);
    customerPortalListener.use(configureGuidedOnboarding);
  });

  // Listen to Events from internal tools Spaces
  listener.namespace('space:internal-tools', (internalToolsListener) => {
    internalToolsListener.use(validateAdminData);
    internalToolsListener.use(enableAuditLogging);
  });

  // Listen to Events from partner integration Spaces
  listener.namespace('space:partner-integration', (partnerIntegrationListener) => {
    partnerIntegrationListener.use(configureApiWebhooks);
    partnerIntegrationListener.use(enableBulkProcessing);
  });

  // Listen to Events from general Spaces (default)
  listener.namespace('space:general', (generalSpaceListener) => {
    generalSpaceListener.use(validateBasicData);
  });

const workbook = {
  name: 'Employee Data Processing',
  namespace: 'staging', // Simple string namespace
  sheets: [employeesSheet, departmentsSheet, payrollSheet]
};

const workbook = {
  name: 'Employee Data Processing: ',
  namespace: 'production', // Simple string namespace
  sheets: [employeesSheet, departmentsSheet, payrollSheet]
};

listener.use(configureAllWorkbooks);
listener.use(validateData);

// Listen to Events from Workbooks with "staging" namespace
listener.namespace('workbook:staging', (stagingWorkbookListener) => {
  stagingWorkbookListener.use(migrateStagingDataToProduction);
});

// Listen to Events from Workbooks with "production" namespace
listener.namespace('workbook:production', (productionWorkbookListener) => {
  productionWorkbookListener.use(applyBusinessLogic);
  productionWorkbookListener.use(enableAuditing);
});

// Listen to events from specific Spaces and Workbooks
listener.namespace(['space:admin-tools', 'workbook:critical-data'], (adminCriticalListener) => {
  adminCriticalListener.use(enableHighSecurityMode);
  adminCriticalListener.use(requireApproval);
  adminCriticalListener.use(flagForReview);
});

// With callback function for multiple handlers
listener.filter({ sheet: 'contacts' }, (contactsListener) => {
  contactsListener.on('commit:created', async (event) => {
    console.log('Contact data committed');
    // Process contact data validation
  });

  contactsListener.on('records:created', async (event) => {
    console.log('New contacts added');
    // Handle contact creation workflow
  });
});

// Chaining `filter()` with `on()`
listener
  .filter({ sheet: 'contacts' })
  .on('records:updated', async (event) => {
    console.log('Contact updated');
  // Handle contact updates
  });

// Use wildcard to filter for events initiated by jobs (actorId starts with "us_jb")
listener
  .filter({actorId: "us_jb*"}) // note the * wildcard
  .on("commit:created", async (event) => {
    // Get the job details that caused this commit
    const { data: job } = await api.jobs.get(event.context.actorId);
    console.log(`Job ${job.operation} caused a commit in sheet ${event.context.sheetId}`);
    // ...React to job-initiated commits
  });

// Progressive filtering for highly specific event targeting
listener
  .namespace('space:third-party-integrations')
  .filter({job: `workbook:submit`})
  .filter({"payload.status": "failed"})
  .on('job:updated', async (event) => {
    const { data: job } = await api.jobs.get(event.context.jobId);
    handleFailedThirdPartySubmissions(job);
  });