@eddeee888/gcg-typescript-resolver-files 0.16.0 → 0.18.0

package/src/validatePresetConfig/validatePresetConfig.spec.ts

@@ -0,0 +1,706 @@
+import {
+  type RawPresetConfig,
+  type ParsedPresetConfig,
+  validatePresetConfig,
+} from './validatePresetConfig.js';
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+const defaultExpected: ParsedPresetConfig = {
+  mode: 'modules',
+  resolverMainFile: 'resolvers.generated.ts',
+  resolverMainFileMode: 'merged',
+  resolverRelativeTargetDir: 'resolvers',
+  resolverTypesPath: './types.generated.ts',
+  resolverGeneration: {
+    query: '*',
+    mutation: '*',
+    subscription: '*',
+    scalar: '*',
+    object: '*',
+    union: '',
+    interface: '',
+    enum: '',
+  },
+  mergeSchema: {
+    path: 'schema.generated.graphqls',
+    config: {},
+  },
+  typeDefsFilePath: './typeDefs.generated.ts',
+  typeDefsFileMode: 'merged',
+  mappersRelativeTargetDir: './',
+  mappersFileExtension: '.mappers.ts',
+  mappersSuffix: 'Mapper',
+  moduleNamingMode: -1,
+  scalarsModule: 'graphql-scalars',
+  scalarsOverrides: {},
+  externalResolvers: {},
+  typesPluginsConfig: {},
+  whitelistedModules: [],
+  blacklistedModules: [],
+  tsMorphProjectOptions: {
+    skipAddingFilesFromTsConfig: true,
+    tsConfigFilePath: expect.any(String), // this'd be a local path, so no need to test
+  },
+  fixObjectTypeResolvers: {
+    object: 'fast',
+    enum: 'fast',
+  },
+  emitLegacyCommonJSImports: true,
+  importExtension: '',
+};
+
+describe('validatePresetConfig - general', () => {
+  it('returns correct default config', () => {
+    const parsed = validatePresetConfig({});
+
+    expect(parsed).toEqual(defaultExpected);
+  });
+
+  it('throws if wrong mode is provided', () => {
+    expect(() => validatePresetConfig({ mode: 'this_will_never_be' })).toThrow(
+      'Validation - presetConfig.mode must be "merged" or "modules" (default is "modules")'
+    );
+  });
+
+  it("returns result.typeDefsFileMode = 'modules' if config.typeDefsFileMode == modules", () => {
+    const parsed = validatePresetConfig({ typeDefsFileMode: 'modules' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      typeDefsFileMode: 'modules',
+    });
+  });
+
+  it("returns result.resolverMainFileMode = 'merged' if config.resolverMainFileMode == merged", () => {
+    const parsed = validatePresetConfig({ resolverMainFileMode: 'merged' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      resolverMainFileMode: 'merged',
+    });
+  });
+
+  it("returns result.resolverMainFileMode = 'modules' if config.resolverMainFileMode == modules", () => {
+    const parsed = validatePresetConfig({ resolverMainFileMode: 'modules' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      resolverMainFileMode: 'modules',
+    });
+  });
+
+  it('throws if result.resolverMainFileMode is not expected', () => {
+    expect(() =>
+      validatePresetConfig({ resolverMainFileMode: 'not_valid_value' })
+    ).toThrow(
+      'Validation - presetConfig.resolverMainFileMode must be "merged" or "modules" (default is "merged")'
+    );
+  });
+
+  it("returns result.typeDefsFileMode = 'mergedWhitelisted' if config.typeDefsFileMode == mergedWhitelisted", () => {
+    const parsed = validatePresetConfig({
+      typeDefsFileMode: 'mergedWhitelisted',
+    });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      typeDefsFileMode: 'mergedWhitelisted',
+    });
+  });
+
+  it('throws if result.typeDefsFileMode is not expected', () => {
+    expect(() => validatePresetConfig({ typeDefsFileMode: '' })).toThrow(
+      'presetConfig.typeDefsFileMode must be "merged", "mergedWhitelisted" or "modules" (default is "merged")'
+    );
+  });
+
+  it("returns result.typeDefsFilePath = './typeDefs.generated.ts' if config.typeDefsFilePath == true", () => {
+    const parsed = validatePresetConfig({ typeDefsFilePath: true });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      typeDefsFilePath: './typeDefs.generated.ts',
+    });
+  });
+  it('returns result.typeDefsFilePath = false if config.typeDefsFilePath == false', () => {
+    const parsed = validatePresetConfig({ typeDefsFilePath: false });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      typeDefsFilePath: false,
+    });
+  });
+  it("returns result.typeDefsFilePath = '' if config.typeDefsFilePath == '' ", () => {
+    const parsed = validatePresetConfig({ typeDefsFilePath: '' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      typeDefsFilePath: '',
+    });
+  });
+
+  it('returns custom result.resolverTypesPath = config.resolverTypesPath if config.resolverTypesPath is not falsy', () => {
+    const parsed = validatePresetConfig({
+      resolverTypesPath: './types.gen.ts',
+    });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      resolverTypesPath: './types.gen.ts',
+    });
+  });
+  it('throws if if config.resolverTypesPath is falsy', () => {
+    expect(() => validatePresetConfig({ resolverTypesPath: '' })).toThrow(
+      'Validation - presetConfig.resolverTypesPath is required'
+    );
+  });
+
+  it('returns custom result.resolverRelativeTargetDir = config.resolverRelativeTargetDir', () => {
+    const parsed = validatePresetConfig({ resolverRelativeTargetDir: '' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      resolverRelativeTargetDir: '',
+    });
+  });
+
+  it('returns custom result.resolverMainFile = config.resolverMainFile', () => {
+    const parsed = validatePresetConfig({
+      resolverMainFile: 'resolvers.gen.ts',
+    });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      resolverMainFile: 'resolvers.gen.ts',
+    });
+  });
+  it('throws if config.resolverMainFile is not a valid filename', () => {
+    expect(() => validatePresetConfig({ resolverMainFile: 'aaa' })).toThrow(
+      'presetConfig.mainFile must be a valid file name'
+    );
+  });
+
+  it('returns custom result.mappersFileExtension = config.mappersFileExtension', () => {
+    const parsed = validatePresetConfig({ mappersFileExtension: '.map.ts' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      mappersFileExtension: '.map.ts',
+    });
+  });
+
+  it('returns custom result.mappersSuffix = config.mappersSuffix', () => {
+    const parsed = validatePresetConfig({ mappersSuffix: '_Map' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      mappersSuffix: '_Map',
+    });
+  });
+
+  it('returns result.fixObjectTypeResolvers object with every key set as "smart" if input is set as "smart"', () => {
+    const parsed = validatePresetConfig({ fixObjectTypeResolvers: 'smart' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      fixObjectTypeResolvers: {
+        object: 'smart',
+        enum: 'smart',
+      },
+    });
+  });
+
+  it('returns result.fixObjectTypeResolvers object with every key set as "disabled" if input is set as "disabled"', () => {
+    const parsed = validatePresetConfig({ fixObjectTypeResolvers: 'disabled' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      fixObjectTypeResolvers: {
+        object: 'disabled',
+        enum: 'disabled',
+      },
+    });
+  });
+
+  it('returns result.fixObjectTypeResolvers object when input is an object', () => {
+    const parsed = validatePresetConfig({
+      fixObjectTypeResolvers: {
+        object: 'smart',
+        enum: 'disabled',
+      },
+    });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      fixObjectTypeResolvers: {
+        object: 'smart',
+        enum: 'disabled',
+      },
+    });
+  });
+
+  it('returns result.fixObjectTypeResolvers fields as "disabled" if the input object fields are not "smart" or "disabled"', () => {
+    const parsed = validatePresetConfig({
+      fixObjectTypeResolvers: {
+        object: 'never_an_option',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        enum: undefined as any,
+      },
+    });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      fixObjectTypeResolvers: {
+        object: 'disabled',
+        enum: 'disabled',
+      },
+    });
+  });
+
+  it('returns result.emitLegacyCommonJSImports = false if set to false', () => {
+    const parsed = validatePresetConfig({ emitLegacyCommonJSImports: false });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      emitLegacyCommonJSImports: false,
+      importExtension: '.js',
+    });
+  });
+
+  it('throws if config.typesPluginsConfig.emitLegacyCommonJSImports is used', () => {
+    expect(() =>
+      validatePresetConfig({
+        typesPluginsConfig: {
+          emitLegacyCommonJSImports: false,
+        },
+      })
+    ).toThrow(
+      'Validation - presetConfig.typesPluginsConfig.emitLegacyCommonJSImports is not supported. Use presetConfig.emitLegacyCommonJSImports instead.'
+    );
+  });
+
+  it('throws if result.fixObjectTypeResolvers is not valid', () => {
+    expect(() =>
+      validatePresetConfig({ fixObjectTypeResolvers: 'not-valid-for-sure' })
+    ).toThrow(
+      'Validation - presetConfig.fixObjectTypeResolvers must be an object, "smart", "fast" or "disabled" (default is "fast")'
+    );
+  });
+
+  it('throws if config.typesPluginsConfig.scalars is used', () => {
+    expect(() =>
+      validatePresetConfig({ typesPluginsConfig: { scalars: 'asdas' } })
+    ).toThrow(
+      'presetConfig.typesPluginsConfig.scalars is not supported. Use presetConfig.scalarsOverrides instead.'
+    );
+  });
+
+  it('returns result.scalarsModule = false if config.scalarsModule == false', () => {
+    const parsed = validatePresetConfig({ scalarsModule: false });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      scalarsModule: false,
+    });
+  });
+  it('returns custom result.scalarsModule = false if config.scalarsModule == false', () => {
+    const parsed = validatePresetConfig({
+      scalarsModule: '@someother/graphql-scalars',
+    });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      scalarsModule: '@someother/graphql-scalars',
+    });
+  });
+
+  it('returns correct result if config.externalResolvers and config.scalarsOverrides are used together', () => {
+    const parsed = validatePresetConfig({
+      externalResolvers: {
+        DateTime: 'module#DateTimeResolver',
+      },
+      scalarsOverrides: {
+        Currency: {
+          resolver: 'module#CurrencyResolver',
+          type: 'unknown',
+        },
+      },
+    });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      externalResolvers: {
+        DateTime: 'module#DateTimeResolver',
+      },
+      scalarsOverrides: {
+        Currency: {
+          resolver: 'module#CurrencyResolver',
+          type: 'unknown',
+        },
+      },
+    });
+  });
+});
+
+describe('validatePresetConfig - mode: modules', () => {
+  it('returns custom result.whitelistedModules = config.whitelistedModules', () => {
+    const parsed = validatePresetConfig({ whitelistedModules: ['moduleA'] });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      whitelistedModules: ['moduleA'],
+    });
+  });
+  it('returns result.whitelistedModules = [] if config.whitelistedModules is falsy', () => {
+    const parsed = validatePresetConfig({ whitelistedModules: undefined });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      whitelistedModules: [],
+    });
+  });
+  it('throws if config.whitelistedModules is truthy but not an array', () => {
+    expect(() =>
+      validatePresetConfig({ whitelistedModules: true } as never)
+    ).toThrow(
+      'Validation - presetConfig.whitelistedModules must be an array if provided'
+    );
+  });
+
+  it('returns custom result.blacklistedModules = config.blacklistedModules', () => {
+    const parsed = validatePresetConfig({ blacklistedModules: ['moduleA'] });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      blacklistedModules: ['moduleA'],
+    });
+  });
+  it('returns result.blacklistedModules = [] if config.blacklistedModules is falsy', () => {
+    const parsed = validatePresetConfig({ blacklistedModules: undefined });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      blacklistedModules: [],
+    });
+  });
+  it('throws if config.blacklistedModules is truthy but not an array', () => {
+    expect(() =>
+      validatePresetConfig({ blacklistedModules: true } as never)
+    ).toThrow(
+      'Validation - presetConfig.blacklistedModules must be an array if provided'
+    );
+  });
+});
+
+describe('validatePresetConfig - mode: merged', () => {
+  it('returns correct default config for merged mode', () => {
+    const parsed = validatePresetConfig({ mode: 'merged' });
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      mode: 'merged',
+      resolverRelativeTargetDir: '',
+    });
+  });
+
+  it('throws if config.whitelistedModules is provided', () => {
+    expect(() =>
+      validatePresetConfig({
+        mode: 'merged',
+        whitelistedModules: ['moduleA'],
+      })
+    ).toThrow(
+      'Validation - presetConfig.whitelistedModules can only be used with presetConfig.mode == "modules"'
+    );
+  });
+  it('throws if config.blacklistedModules is provided', () => {
+    expect(() =>
+      validatePresetConfig({
+        mode: 'merged',
+        blacklistedModules: ['moduleA'],
+      })
+    ).toThrow(
+      'Validation - presetConfig.blacklistedModules can only be used with presetConfig.mode == "modules"'
+    );
+  });
+});
+
+describe('validatePresetConfig - importExtension', () => {
+  it('returns importExtension: ".js" when explicitly set', () => {
+    const parsed = validatePresetConfig({ importExtension: '.js' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      importExtension: '.js',
+    });
+  });
+
+  it('returns importExtension: "" when explicitly set to empty string', () => {
+    const parsed = validatePresetConfig({ importExtension: '' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      importExtension: '',
+    });
+  });
+
+  it('returns custom importExtension when provided', () => {
+    const parsed = validatePresetConfig({ importExtension: '.mjs' });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      importExtension: '.mjs',
+    });
+  });
+
+  it('importExtension takes precedence over emitLegacyCommonJSImports when both are set', () => {
+    const parsed = validatePresetConfig({
+      importExtension: '.mjs',
+      emitLegacyCommonJSImports: false,
+    });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      importExtension: '.mjs',
+      emitLegacyCommonJSImports: false,
+    });
+  });
+
+  it('returns importExtension: "" when emitLegacyCommonJSImports is true (backward compatibility)', () => {
+    const parsed = validatePresetConfig({ emitLegacyCommonJSImports: true });
+
+    expect(parsed).toEqual({
+      ...defaultExpected,
+      emitLegacyCommonJSImports: true,
+      importExtension: '',
+    });
+  });
+
+  describe('base config inheritance', () => {
+    it('inherits importExtension from base config when not specified in preset', () => {
+      const parsed = validatePresetConfig({}, { importExtension: '.ts' });
+
+      expect(parsed).toEqual({
+        ...defaultExpected,
+        importExtension: '.ts',
+        emitLegacyCommonJSImports: true,
+      });
+    });
+
+    it('preset importExtension overrides base config', () => {
+      const parsed = validatePresetConfig(
+        { importExtension: '.mjs' },
+        { importExtension: '.ts' }
+      );
+
+      expect(parsed).toEqual({
+        ...defaultExpected,
+        importExtension: '.mjs',
+      });
+    });
+
+    it('inherits emitLegacyCommonJSImports from base config', () => {
+      const parsed = validatePresetConfig(
+        {},
+        { emitLegacyCommonJSImports: false }
+      );
+
+      expect(parsed).toEqual({
+        ...defaultExpected,
+        emitLegacyCommonJSImports: false,
+        importExtension: '.js',
+      });
+    });
+
+    it('preset emitLegacyCommonJSImports overrides base config', () => {
+      const parsed = validatePresetConfig(
+        { emitLegacyCommonJSImports: true },
+        { emitLegacyCommonJSImports: false }
+      );
+
+      expect(parsed).toEqual({
+        ...defaultExpected,
+        emitLegacyCommonJSImports: true,
+        importExtension: '',
+      });
+    });
+
+    it('uses defaults when base config is not provided', () => {
+      const parsed = validatePresetConfig({});
+
+      expect(parsed).toEqual(defaultExpected);
+    });
+
+    it('uses defaults when base config is undefined', () => {
+      const parsed = validatePresetConfig({}, undefined);
+
+      expect(parsed).toEqual(defaultExpected);
+    });
+
+    it('preset importExtension takes precedence over base emitLegacyCommonJSImports', () => {
+      const parsed = validatePresetConfig(
+        { importExtension: '.ts' },
+        { emitLegacyCommonJSImports: false }
+      );
+
+      expect(parsed).toEqual({
+        ...defaultExpected,
+        emitLegacyCommonJSImports: false,
+        importExtension: '.ts',
+      });
+    });
+
+    it('base importExtension takes precedence over base emitLegacyCommonJSImports', () => {
+      const parsed = validatePresetConfig(
+        {},
+        { importExtension: '.mts', emitLegacyCommonJSImports: false }
+      );
+
+      expect(parsed).toEqual({
+        ...defaultExpected,
+        emitLegacyCommonJSImports: false,
+        importExtension: '.mts',
+      });
+    });
+  });
+});
+
+describe('validatePresetConfig - resolverGeneration', () => {
+  it.each<{
+    input: 'disabled' | 'recommended' | 'all' | 'minimal';
+    expected: ParsedPresetConfig['resolverGeneration'];
+  }>([
+    {
+      input: 'disabled',
+      expected: {
+        query: '',
+        mutation: '',
+        subscription: '',
+        scalar: '',
+        object: '',
+        union: '',
+        interface: '',
+        enum: '',
+      },
+    },
+    {
+      input: 'minimal',
+      expected: {
+        query: '*',
+        mutation: '*',
+        subscription: '*',
+        scalar: '*',
+        object: '',
+        union: '',
+        interface: '',
+        enum: '',
+      },
+    },
+    {
+      input: 'recommended',
+      expected: {
+        query: '*',
+        mutation: '*',
+        subscription: '*',
+        scalar: '*',
+        object: '*',
+        union: '',
+        interface: '',
+        enum: '',
+      },
+    },
+    {
+      input: 'all',
+      expected: {
+        query: '*',
+        mutation: '*',
+        subscription: '*',
+        scalar: '*',
+        object: '*',
+        union: '*',
+        interface: '*',
+        enum: '*',
+      },
+    },
+  ])(
+    'correctly returns the parsed "$input" resolverGeneration object',
+    ({ input, expected }) => {
+      const result = validatePresetConfig({ resolverGeneration: input });
+
+      expect(result.resolverGeneration).toEqual(expected);
+    }
+  );
+
+  it('correctly returns provided resolverGeneration object', () => {
+    const result = validatePresetConfig({
+      resolverGeneration: {
+        query: '*.Query.*',
+        mutation: '!*.Mutation.*',
+      },
+    });
+
+    expect(result.resolverGeneration).toEqual({
+      query: '*.Query.*',
+      mutation: '!*.Mutation.*',
+      subscription: '',
+      scalar: '',
+      object: '',
+      union: '',
+      interface: '',
+      enum: '',
+    });
+  });
+
+  it('throws if invalid resolverGeneration is provided', () => {
+    expect(() =>
+      validatePresetConfig({ resolverGeneration: 'omg_what_is_this' })
+    ).toThrow(
+      'Validation - presetConfig.resolverGeneration must be an object, "disabled", "recommended", "minimal" or "all" (default is "recommended")'
+    );
+  });
+
+  describe('validatePresetConfig - mergeSchema', () => {
+    it.each<{
+      input: RawPresetConfig['mergeSchema'];
+      expected: ParsedPresetConfig['mergeSchema'];
+    }>([
+      {
+        input: false,
+        expected: false,
+      },
+      {
+        input: true,
+        expected: {
+          path: 'schema.generated.graphqls',
+          config: {},
+        },
+      },
+      {
+        input: 'schema.gen.gql',
+        expected: {
+          path: 'schema.gen.gql',
+          config: {},
+        },
+      },
+      {
+        input: {
+          path: 'omg.graphql',
+          config: { sort: true },
+        },
+        expected: {
+          path: 'omg.graphql',
+          config: { sort: true },
+        },
+      },
+    ])(
+      'correctly returns the parsed "$input" resolverGeneration object',
+      ({ input, expected }) => {
+        const result = validatePresetConfig({ mergeSchema: input });
+
+        expect(result.mergeSchema).toEqual(expected);
+      }
+    );
+  });
+});