Dangerjs fail when I try to split dangerfile to small parts

[Sly777]

Hey everyone,

I'm trying to split dangerfile into small parts because we added many checks/automation so it's super helpful but it gets harder to manage it. but when I try to make it, it always gives me this error;

Unable to evaluate the Dangerfile
 
Hey there, it looks like you're trying to import the danger module. Turns out
that the code you write in a Dangerfile.js is actually a bit of a sneaky hack. 

When running Danger, the import or require for Danger is removed before the code
is evaluated. Instead all of the imports are added to the global runtime, so if
you are importing Danger to use one of it's functions - you should instead just
use the global object for the root DSL elements.

There is a spectrum thread for discussion here:
  - https://spectrum.chat/?t=0a005b56-31ec-4919-9a28-ced623949d4d

I really couldn't find any way to run it properly. Do you have any idea how it would work? This is my example to run;

// ./DANGERFILE.TS
//
//
import { OtherChecks } from './dangerjs/checks/other';
OtherChecks();

// ./dangerjs/checks/other.ts
//
//
import mentor from 'danger-plugin-mentor';
import { isGoingToProd, isSkipDanger } from '../variables';

export function OtherChecks() {
  if (!isSkipDanger) {
    if (!isGoingToProd) {
      mentor();
    }
  }
}

// ./dangerjs/variable.ts
//
//
import { danger } from 'danger';
import {
  committedFiles,
  inCommit,
  prTitle,
  linkToSourceRepo,
} from 'danger-plugin-toolbox';

//
// CONSTS
//
export const packageChanged: boolean = inCommit('package.json');
export const lockfileChanged: boolean = inCommit('yarn.lock');
export const npmLockfile: boolean = inCommit('package-lock.json');
export const allFilesLen: number = committedFiles.length;
export const isWIP: boolean = prTitle.includes('[WIP]');
export const isSkipped: boolean = prTitle.includes('[SKIP]');
export const isSkipDanger: boolean = prTitle.includes('[SKIP-DANGER]');
export const { assignees } = danger.github.pr;

// gits
export const targetBranch = danger.github.pr.base.ref;
export const headBranch = danger.github.pr.head.ref;
export const isMergeRefMaster = targetBranch === 'master';
export const isMergeRefProd = targetBranch === 'production';
export const isMergeHeadDev = headBranch === 'dev';
export const isMergeHeadMaster = headBranch === 'master';
export const isGoingToProd = isMergeRefProd && isMergeHeadMaster;

[orta]

As the error says, Danger JS uses globals under the hood - so you don't import from the danger module. You can just remove import {danger} from "danger" to make it work.

[gigamac]

if you are breaking down Dangerfile.ts into smaller components, and compiling, this doesn't work. I have tried quite a few options, finally using tsc before running danger to at least get danger to evaluate the file and its imports, but typescript won't allow danger not being imported ....

[fbartho]

@gigamac you can totally decompose Dangerfiles into multiple files, you just need a small typescript stub to deal with the ambient danger declaration.

I can provide an example if you ping me again tomorrow.

[gigamac]

that sounds like a plan! would appreciate it thanks....

I found another way also: as danger is in global runtime, using
declare var git:any;
and so on got me through to a working example in the pipeline...

[fbartho]

Here's an example from one of the repos I work on

Every file in scripts/danger/lib is imported into the Dangerfiles (main.ts/graphql.ts)
Each one starts with import "./danger-import"

And the contents of danger-import.ts are:

// DangerJS has a weird compile/runtime environment, but this is a stable detail!
// Extra files that want to import danger need this to make typescript happy.
//
// Briefly documented here:
// https://github.com/danger/danger-js/blob/main/docs/usage/extending-danger.html.md#writing-your-plugin

import type { DangerRuntimeContainer, Scheduleable } from "danger";
import type { DangerDSLType } from "danger/distribution/dsl/DangerDSL";

export {};

// Provides dev-time type structures for  `danger` - doesn't affect runtime.
declare global {
	let danger: DangerDSLType;
	
	function warn(message: string, file?: string, line?: number): void;
	function fail(message: string, file?: string, line?: number): void;
	function markdown(message: string, file?: string, line?: number): void;
	function message(message: string, file?: string, line?: number): void;
	
	// ====  You probably don't need the following declarations, I'm doing something fancy to truncate if there's too much output ====
	
	const results: DangerRuntimeContainer;
	/**
	 * A Dangerfile, in Peril, is evaluated as a script, and so async code does not work
	 * out of the box. By using the `schedule` function you can now register a
	 * section of code to evaluate across multiple tick cycles.
	 *
	 * `schedule` currently handles two types of arguments, either a promise or a function with a resolve arg.
	 *
	 * @param {Function} asyncFunction the function to run asynchronously
	 */
	function schedule(asyncFunction: Scheduleable): void;
}

[gigamac]

thanks (sorry for slow - I saw this a while back but haven't had the opportunity to try it out and wanted to reply with feedback).
Will feedback as soon as I get some opportunity

[wilhen01]

Can confirm this solution works - thanks @fbartho! I had to add function message(message: string, file?: string, line?: number): void; to the declare global block