@modern-js/core 1.0.0-alpha.3

package/tests/loadEnv.test.ts

@@ -0,0 +1,100 @@
+import path from 'path';
+import fs from 'fs';
+import { exec } from 'child_process';
+import { loadEnv } from '@/loadEnv';
+
+const fixture = path.resolve(__dirname, './fixtures/load-env');
+
+fs.mkdirSync(fixture);
+
+const createFixtures = (
+  dir: string,
+  files: {
+    name: string;
+    content: string;
+  }[],
+) => {
+  fs.mkdirSync(path.join(fixture, dir));
+  for (const { name, content } of files) {
+    fs.writeFileSync(path.join(fixture, dir, name), content, 'utf8');
+  }
+};
+
+describe('load environment variables', () => {
+  const defaultEnv = process.env;
+
+  beforeEach(() => (process.env = { ...defaultEnv }));
+
+  afterAll(() => {
+    process.env = { ...defaultEnv };
+    exec(`rm -rf ${fixture}`);
+  });
+
+  test(`support .env file`, () => {
+    createFixtures('base', [
+      {
+        name: '.env',
+        content: `DB_HOST=localhost
+        DB_USER=root
+        DB_PASS=root
+        `,
+      },
+    ]);
+    loadEnv(path.join(fixture, 'base'));
+
+    expect(process.env.DB_HOST).toBe('localhost');
+
+    expect(process.env.DB_USER).toBe('root');
+
+    expect(process.env.DB_PASS).toBe('root');
+  });
+
+  test(`support "environment" .env file`, () => {
+    createFixtures('environment', [
+      {
+        name: '.env',
+        content: `DB_HOST=localhost
+        DB_USER=root
+        DB_PASS=root
+        `,
+      },
+      {
+        name: '.env.production',
+        content: `DB_HOST=localhost
+        DB_USER=root-local-dev
+        `,
+      },
+    ]);
+
+    process.env.NODE_ENV = 'production';
+
+    loadEnv(path.join(fixture, 'environment'));
+
+    expect(process.env.DB_HOST).toBe('localhost');
+
+    expect(process.env.DB_USER).toBe('root-local-dev');
+
+    expect(process.env.DB_PASS).toBe('root');
+
+    delete process.env.NODE_ENV;
+  });
+
+  test(`support dotenv-expand`, () => {
+    createFixtures('expand', [
+      {
+        name: '.env',
+        content: `DB_HOST=localhost
+        DB_USER=\${DB_HOST}001
+        DB_PASS=root
+        `,
+      },
+    ]);
+    loadEnv(path.join(fixture, 'expand'));
+
+    expect(process.env.DB_HOST).toBe('localhost');
+
+    expect(process.env.DB_USER).toBe('localhost001');
+
+    expect(process.env.DB_PASS).toBe('root');
+  });
+});

package/tests/loadPlugin.test.ts

@@ -0,0 +1,29 @@
+import path from 'path';
+import { loadPlugins } from '@/loadPlugins';
+
+describe('load plugins', () => {
+  test('should load user plugin successfully', () => {
+    const fixture = path.resolve(
+      __dirname,
+      './fixtures/load-plugin/user-plugins',
+    );
+
+    const plugins = loadPlugins(fixture, [
+      { cli: path.join(fixture, './test-plugin-a.js') },
+      { server: './test-plugin-b' },
+    ]);
+
+    expect(plugins).toEqual([
+      { cli: { name: 'a' } },
+      { server: { name: 'b' } },
+    ]);
+  });
+
+  test(`should throw error when plugin not found `, () => {
+    const fixture = path.resolve(__dirname, './fixtures/load-plugin/not-found');
+
+    expect(() => {
+      loadPlugins(fixture, [{ cli: './test-plugin-a' }, { cli: './plugin-b' }]);
+    }).toThrowError(/^Can not find plugin /);
+  });
+});

package/tests/mergeConfig.test.ts

@@ -0,0 +1,78 @@
+import { mergeConfig } from '@/config/mergeConfig';
+
+describe('load plugins', () => {
+  test('should replace property deeply', () => {
+    expect(
+      mergeConfig([
+        {
+          source: { disableDefaultEntries: false },
+          output: { polyfill: 'usage' },
+        },
+        {
+          source: { disableDefaultEntries: true },
+          output: { polyfill: 'entry' },
+        },
+      ]),
+    ).toEqual({
+      source: { disableDefaultEntries: true },
+      output: { polyfill: 'entry' },
+    });
+  });
+
+  test(`should set value when property value is undefined `, () => {
+    expect(
+      mergeConfig([
+        { source: { entries: { app: './App.tsx' } } },
+        { source: { entries: { app2: './src/App2.tsx' } } },
+        { server: { baseUrl: './a' } },
+      ]),
+    ).toEqual({
+      source: {
+        entries: {
+          app: './App.tsx',
+          app2: './src/App2.tsx',
+        },
+      },
+      server: { baseUrl: './a' },
+    });
+  });
+
+  test(`should merge array value`, () => {
+    expect(
+      mergeConfig([
+        { source: { envVars: ['a', 'b'] } },
+        { source: { globalVars: { A: '1' } } },
+        {
+          source: {
+            disableDefaultEntries: true,
+            envVars: ['c', 'd'],
+            globalVars: { B: '2' },
+          },
+        },
+      ]),
+    ).toEqual({
+      source: {
+        disableDefaultEntries: true,
+        envVars: ['a', 'b', 'c', 'd'],
+        globalVars: {
+          A: '1',
+          B: '2',
+        },
+      },
+    });
+  });
+
+  test(`should merge function and object value`, () => {
+    const config = mergeConfig([
+      { source: { alias: { a: 'b' } } },
+      { source: { alias: () => ({ c: 'd' }) } },
+      { tools: { webpack: () => ({}) } },
+    ]);
+    expect(Array.isArray(config.source.alias)).toBe(true);
+    expect(config?.source?.alias?.length).toBe(2);
+    expect(typeof (config.source.alias as Array<any>)[1]).toBe('function');
+
+    expect(Array.isArray(config.tools.webpack)).toBe(true);
+    expect(config.tools.webpack?.length).toBe(1);
+  });
+});

package/tests/repeatKeyWarning.test.ts

@@ -0,0 +1,68 @@
+import { repeatKeyWarning } from '@/utils/repeatKeyWarning';
+import { UserConfig } from '@/config';
+
+jest.spyOn(process, 'exit').mockImplementation();
+
+describe('check repeated keys in user config', () => {
+  test(`should exit with error`, () => {
+    expect(() => {
+      repeatKeyWarning(
+        {
+          type: 'object',
+          properties: {
+            a: {
+              type: 'object',
+              properties: {
+                b: {
+                  type: 'object',
+                  properties: { c: { type: ['boolean', 'object'] } },
+                },
+              },
+            },
+          },
+        },
+        { a: { b: { c: true } } } as UserConfig,
+        { a: { b: { c: false } } } as UserConfig,
+      );
+    }).toThrowError(
+      'The same configuration a.b.c exists in modern.config.js and package.json.',
+    );
+  });
+
+  test(`should exit succcessfully`, () => {
+    expect(
+      repeatKeyWarning(
+        {
+          type: 'object',
+          properties: {
+            a: {
+              type: 'object',
+              properties: { b: { type: 'string' } },
+            },
+          },
+          c: {
+            type: 'object',
+            proeperties: {
+              d: {
+                type: 'object',
+                properties: { e: { type: 'string' } },
+              },
+              f: { type: 'string' },
+            },
+          },
+        },
+        {
+          a: { b: 'name' },
+          c: { d: { e: 's' } },
+        } as UserConfig,
+        {
+          a: {},
+          c: {
+            d: {},
+            f: 'ss',
+          },
+        } as UserConfig,
+      ),
+    ).toBeUndefined();
+  });
+});

package/tests/schema.test.ts

@@ -0,0 +1,109 @@
+import { patchSchema, traverseSchema } from '@/config/schema';
+
+describe('patch schemas', () => {
+  test('should add schema succcessfully', () => {
+    const schema = patchSchema([
+      {
+        target: 'foo',
+        schema: { type: 'string' },
+      },
+      {
+        target: 'deploy.microFrontend.foo',
+        schema: { type: 'number' },
+      },
+    ]);
+
+    expect(schema.properties).toHaveProperty('foo');
+
+    expect(
+      schema.properties.deploy.properties.microFrontend.properties,
+    ).toHaveProperty('foo');
+  });
+
+  test('should throw error when node is undefined', () => {
+    expect(() => {
+      patchSchema([
+        {
+          target: 'deploy.a.foo',
+          schema: { type: 'string' },
+        },
+      ]);
+    }).toThrowError(/^add schema deploy\.a error$/);
+  });
+
+  test(`should throw error on empty target property`, () => {
+    expect(() => {
+      patchSchema([
+        {
+          target: '',
+          schema: { type: 'object' },
+        },
+      ]);
+    }).toThrowError('should return target property in plugin schema.');
+  });
+
+  test(`support schema array in one schema`, () => {
+    const schema = patchSchema([
+      [
+        {
+          target: 'foo',
+          schema: { type: 'string' },
+        },
+        {
+          target: 'tools.foo',
+          schema: { type: 'number' },
+        },
+      ],
+      {
+        target: 'bar',
+        schema: { type: 'string' },
+      },
+    ]);
+
+    expect(schema.properties).toHaveProperty('foo');
+    expect(schema.properties).toHaveProperty('bar');
+    expect(schema.properties.tools.properties).toHaveProperty('foo');
+  });
+});
+
+describe(`traverse schema`, () => {
+  test(`should return all avaliable keys of current schema`, () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        source: {
+          type: 'object',
+          properties: { alias: { type: ['object', 'function'] } },
+        },
+        a: {
+          type: 'object',
+          properties: {
+            b: {
+              type: 'object',
+              properties: { c: { type: 'object' } },
+            },
+            d: { type: 'string' },
+          },
+        },
+        runtime: {
+          type: 'object',
+          properties: {
+            router: { type: ['object', 'boolean'] },
+            state: { type: ['object', 'boolean'] },
+          },
+        },
+        runtimeByEntries: { patternProperties: { '^$': { type: 'string' } } },
+        dev: { type: ['function', 'string'] },
+      },
+    };
+    expect(traverseSchema(schema as any)).toEqual([
+      'source.alias',
+      'a.b.c',
+      'a.d',
+      'runtime.router',
+      'runtime.state',
+      'runtimeByEntries',
+      'dev',
+    ]);
+  });
+});

package/tests/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@modern-js/tsconfig/base",
+  "compilerOptions": {
+    "declaration": false,
+    "jsx": "preserve",
+    "baseUrl": "./",
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "paths": {
+      "@/*": ["../src/*"]
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "@modern-js/tsconfig/base",
+  "compilerOptions": {
+    "declaration": false,
+    "jsx": "preserve",
+    "baseUrl": "./",
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}