@prosopo/config 0.2.11 → 0.2.13

package/src/vite/vite.backend.config.ts

@@ -0,0 +1,212 @@
+import { AliasOptions, UserConfig } from 'vite'
+import { default as ClosePlugin } from './vite-plugin-close-and-copy.js'
+import { builtinModules } from 'module'
+import { filterDependencies, getDependencies } from '../dependencies.js'
+import { getLogger } from '@prosopo/common'
+import { nodeResolve } from '@rollup/plugin-node-resolve'
+import { viteStaticCopy } from 'vite-plugin-static-copy'
+import { wasm } from '@rollup/plugin-wasm'
+import VitePluginFixAbsoluteImports from './vite-plugin-fix-absolute-imports.js'
+import css from 'rollup-plugin-import-css'
+import nativePlugin from 'rollup-plugin-natives'
+import path from 'path'
+import replace from 'vite-plugin-filter-replace'
+
+const logger = getLogger(`Info`, `vite.backend.config.js`)
+
+const nodeJsPolarsDeps = [
+    'nodejs-polars.android-arm64.node',
+    'nodejs-polars.android-arm-eabi.node',
+    'nodejs-polars.win32-x64-msvc.node',
+    'nodejs-polars.win32-ia32-msvc.node',
+    'nodejs-polars.win32-arm64-msvc.node',
+    'nodejs-polars.darwin-x64.node',
+    'nodejs-polars.darwin-arm64.node',
+    'nodejs-polars.freebsd-x64.node',
+    'nodejs-polars.linux-x64-musl.node',
+    //'nodejs-polars.linux-x64-gnu.node', // - this is the only file that will be present
+    'nodejs-polars.linux-arm64-musl.node',
+    'nodejs-polars.linux-arm64-gnu.node',
+    'nodejs-polars.linux-arm-gnueabihf.node',
+]
+
+const aliasOptions: AliasOptions = [
+    // Replace the nodejs-polars dependency with the copied .node file to avoid complaints when bundling
+    ...nodeJsPolarsDeps.map((dep) => ({
+        find: `./${dep}`,
+        replacement: 'nodejs-polars.linux-x64-gnu.node',
+    })),
+]
+
+export default async function (
+    packageName: string,
+    packageVersion: string,
+    bundleName: string,
+    packageDir: string,
+    entry: string,
+    command?: string,
+    mode?: string
+): Promise<UserConfig> {
+    // Get all dependencies of the current package
+    const { dependencies: deps, optionalPeerDependencies } = await getDependencies(packageName, true)
+
+    // Assuming node_modules are at the root of the workspace
+    const baseDir = path.resolve('../..')
+    const nodeModulesDir = path.resolve(baseDir, 'node_modules')
+
+    // Output directory is relative to directory of the package
+    const outDir = path.resolve(packageDir, 'dist/bundle')
+
+    // Get rid of any dependencies we don't want to bundle
+    const { external, internal } = filterDependencies(deps, ['aws', 'webpack', 'vite', 'eslint'])
+
+    // Add the node builtins (path, fs, os, etc.) to the external list
+    const allExternal = [
+        ...builtinModules,
+        ...builtinModules.map((m) => `node:${m}`),
+        ...external,
+        ...optionalPeerDependencies,
+    ]
+
+    console.log('allExternal', allExternal)
+
+    logger.info(`Bundling. ${JSON.stringify(internal.slice(0, 10), null, 2)}... ${internal.length} deps`)
+
+    const nodeJsNodeFileToCopy = path.resolve(
+        nodeModulesDir,
+        './nodejs-polars-linux-x64-gnu/nodejs-polars.linux-x64-gnu.node'
+    )
+    logger.info(`.node files to copy ${nodeJsNodeFileToCopy}`)
+
+    const define = {
+        'process.env.WS_NO_BUFFER_UTIL': 'true',
+        'process.env.WS_NO_UTF_8_VALIDATE': 'true',
+        'process.env.PROSOPO_PACKAGE_VERSION': JSON.stringify(packageVersion),
+    }
+
+    logger.info(`Defined vars ${JSON.stringify(define, null, 2)}`)
+
+    const entryAbsolute = path.resolve(packageDir, entry)
+
+    const packageNameShort = packageName.replace('@prosopo/', '')
+
+    const filterEntry = `^${baseDir}/packages/(?!${packageNameShort}/src/${entry.replace(
+        './src/',
+        ''
+    )}$)(?!.*/node_modules/.*$).*$`
+
+    return {
+        resolve: {
+            alias: aliasOptions,
+        },
+        ssr: {
+            noExternal: internal,
+            external: allExternal,
+        },
+        optimizeDeps: {
+            include: ['linked-dep', 'node_modules'],
+            esbuildOptions: {
+                loader: {
+                    '.node': 'file',
+                },
+            },
+        },
+        esbuild: {
+            platform: 'node',
+            target: 'node16',
+        },
+        define,
+        build: {
+            outDir,
+            minify: false,
+            ssr: true,
+            target: 'node16',
+
+            lib: {
+                entry: entryAbsolute,
+                name: bundleName,
+                fileName: `${bundleName}.[name].bundle.js`,
+                formats: ['es'],
+            },
+            modulePreload: { polyfill: false },
+            commonjsOptions: {
+                ignore: function (id) {
+                    // Ignore Executable and Linkable Format (ELF) files from being interpreted as CommonJS. These are
+                    // .node files that contain WebAssembly code. They are not CommonJS modules.
+                    return id.indexOf('nodejs-polars-linux-x64-gnu') > -1
+                },
+            },
+            rollupOptions: {
+                treeshake: 'smallest',
+                external: allExternal,
+                watch: false,
+                output: {
+                    entryFileNames: `${bundleName}.[name].bundle.js`,
+                },
+
+                plugins: [
+                    // This plugin copies .node files but doesn't work for nodejs-polars. Leaving it here in case it's
+                    // useful in the future.
+                    nativePlugin({
+                        // Where we want to physically put the extracted .node files
+                        copyTo: outDir,
+
+                        // Path to the same folder, relative to the output bundle js
+                        destDir: '.',
+
+                        // Generate sourcemap
+                        sourcemap: true,
+
+                        // If the target is ESM, so we can't use `require` (and .node is not supported in `import` anyway), we will need to use `createRequire` instead.
+                        targetEsm: true,
+                    }),
+                    css(),
+                    wasm(),
+                    nodeResolve(),
+                ],
+            },
+        },
+        plugins: [
+            // plugin to replace stuff like import blah from string_encoder/lib/string_encoder.js with import blah from string_encoder
+            VitePluginFixAbsoluteImports(),
+            replace.default([
+                // nodejs-polars is not being transformed by commonjsOptions (above) so we need to do a manual replace of
+                // __dirname here
+                {
+                    filter: ['node_modules/nodejs-polars/bin/native-polars.js'],
+                    replace: {
+                        from: '__dirname',
+                        to: "new URL(import.meta.url).pathname.split('/').slice(0,-1).join('/')",
+                    },
+                },
+                // replace this import
+                {
+                    filter: ['node_modules/nodejs-polars/bin/native-polars.js'],
+                    replace: {
+                        from: '__dirname',
+                        to: "new URL(import.meta.url).pathname.split('/').slice(0,-1).join('/')",
+                    },
+                },
+                // replace any references to main process where we are not expecting it
+                {
+                    filter: new RegExp(filterEntry),
+                    replace: {
+                        from: 'esMain(import.meta)',
+                        to: 'false',
+                    },
+                },
+            ]),
+            // We need the .node files to be available to the bundle
+            viteStaticCopy({
+                targets: [
+                    {
+                        src: nodeJsNodeFileToCopy,
+                        dest: outDir,
+                    },
+                ],
+            }),
+            // plugin to close the bundle after build if not in serve mode
+            command !== 'serve' ? ClosePlugin() : undefined,
+        ],
+    }
+}

package/src/vite/vite.commonjs.config.ts

@@ -0,0 +1,42 @@
+import { UserConfig, defineConfig } from 'vite'
+import { builtinModules } from 'module'
+import { getExternalsFromReferences } from '../dependencies.js'
+import { getLogger } from '@prosopo/common'
+import { default as noBundlePlugin } from 'vite-plugin-no-bundle'
+import VitePluginCloseAndCopy from './vite-plugin-close-and-copy.js'
+import path from 'path'
+import tsconfigPaths from 'vite-tsconfig-paths'
+const log = getLogger(`Info`, `vite.commonjs.config.ts`)
+export default async function (name: string, tsConfigPath: string, entry?: string): Promise<UserConfig> {
+    log.info(`ViteCommonJSConfig: ${name}`)
+    const projectExternal = await getExternalsFromReferences(tsConfigPath, [/dev/])
+    const allExternal = [...builtinModules, ...builtinModules.map((m) => `node:${m}`), ...projectExternal]
+    return defineConfig({
+        ssr: { external: allExternal },
+        plugins: [
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            noBundlePlugin({
+                root: 'src',
+                copy: '**/*.css',
+            }),
+            tsconfigPaths({ projects: [path.resolve('./tsconfig.cjs.json')] }),
+            VitePluginCloseAndCopy(),
+        ],
+        build: {
+            emptyOutDir: true,
+            ssr: true,
+            target: 'node16',
+            outDir: 'dist/cjs',
+            lib: {
+                name,
+                formats: ['cjs'],
+                entry: entry || 'src/index.ts', // required
+            },
+            rollupOptions: {
+                treeshake: false,
+                external: allExternal,
+            },
+        },
+    })
+}

package/src/vite/vite.frontend.config.ts

@@ -0,0 +1,153 @@
+import { ClosePluginOptions } from './vite-plugin-close-and-copy.js'
+import { Drop } from 'esbuild'
+import { UserConfig } from 'vite'
+import { VitePluginCloseAndCopy } from './index.js'
+import { builtinModules } from 'module'
+import { filterDependencies, getDependencies } from '../dependencies.js'
+import { getAliases } from '../polkadot/index.js'
+import { getLogger } from '@prosopo/common'
+import { nodeResolve } from '@rollup/plugin-node-resolve'
+import { viteCommonjs } from '@originjs/vite-plugin-commonjs'
+import { default as viteReact } from '@vitejs/plugin-react'
+import { wasm } from '@rollup/plugin-wasm'
+import css from 'rollup-plugin-import-css'
+import path from 'path'
+import viteTsconfigPaths from 'vite-tsconfig-paths'
+const logger = getLogger(`Info`, `vite.config.js`)
+
+export default async function (
+    packageName: string,
+    bundleName: string,
+    dir: string,
+    entry: string,
+    command?: string,
+    mode?: string,
+    copyOptions?: ClosePluginOptions,
+    tsConfigPaths?: string[]
+): Promise<UserConfig> {
+    logger.info(`Running at ${dir} in ${mode} mode`)
+    const isProduction = mode === 'production'
+    // NODE_ENV must be wrapped in quotes. We just set it to the mode and ignore what's in the env file, otherwise the
+    // mode and NODE_ENV can end up out of sync (one set to development and the other set to production, which causes
+    // issues like this: https://github.com/hashicorp/next-mdx-remote/pull/323
+    process.env.NODE_ENV = `${mode}`
+    logger.info(`NODE_ENV: ${process.env.NODE_ENV}`)
+
+    // Set the env vars that we want to be available in the browser
+    const define = {
+        // used to stop websockets package from breaking
+        'process.env.WS_NO_BUFFER_UTIL': JSON.stringify('true'),
+        'process.env.WS_NO_UTF_8_VALIDATE': JSON.stringify('true'),
+        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
+        'process.env.PROTOCOL_CONTRACT_ADDRESS': JSON.stringify(process.env.PROTOCOL_CONTRACT_ADDRESS),
+        'process.env.SUBSTRATE_NODE_URL': JSON.stringify(process.env.SUBSTRATE_NODE_URL),
+        'process.env.DEFAULT_ENVIRONMENT': JSON.stringify(process.env.DEFAULT_ENVIRONMENT),
+        'process.env.SERVER_URL': JSON.stringify(process.env.SERVER_URL),
+        // only needed if bundling with a site key
+        'process.env.PROSOPO_SITE_KEY': JSON.stringify(process.env.PROSOPO_SITE_KEY),
+    }
+
+    logger.info(`Env vars: ${JSON.stringify(define, null, 4)}`)
+
+    // Get all dependencies of the current package
+    const { dependencies: deps, optionalPeerDependencies } = await getDependencies(packageName, isProduction)
+
+    // Get rid of any dependencies we don't want to bundle
+    const { external, internal } = filterDependencies(deps, ['pm2', 'nodejs-polars', 'aws', 'webpack', 'vite'])
+
+    // Add the node builtins (path, fs, os, etc.) to the external list
+    const allExternal = [
+        ...builtinModules,
+        ...builtinModules.map((m) => `node:${m}`),
+        ...external,
+        ...optionalPeerDependencies,
+    ]
+    logger.info(`Bundling. ${JSON.stringify(internal.slice(0, 10), null, 2)}... ${internal.length} deps`)
+    const alias = isProduction ? getAliases(dir) : []
+
+    // Required to print RegExp in console (e.g. alias keys)
+    const proto = RegExp.prototype as any
+    proto['toJSON'] = RegExp.prototype.toString
+    logger.info(`aliases ${JSON.stringify(alias, null, 2)}`)
+
+    // drop console logs if in production mode
+    const drop: Drop[] | undefined = mode === 'production' ? ['console', 'debugger'] : undefined
+
+    return {
+        server: {
+            host: '127.0.0.1',
+        },
+        mode: mode || 'development',
+        optimizeDeps: {
+            include: ['linked-dep', 'esm-dep > cjs-dep', 'node_modules'], //'node_modules'
+            //exclude: ['react', 'react-dom'],
+        },
+        esbuild: {
+            platform: 'browser',
+            target: ['es2020', 'chrome60', 'edge18', 'firefox60', 'node12', 'safari11'],
+            drop,
+        },
+        define,
+        // resolve: {
+        //     alias,
+        // },
+
+        build: {
+            outDir: path.resolve(dir, 'dist/bundle'),
+            minify: isProduction,
+            ssr: false,
+            lib: {
+                entry: path.resolve(dir, entry),
+                name: bundleName,
+                fileName: `${bundleName}.bundle.js`,
+                // sets the bundle to an instantly invoked function expression (IIFE)
+                formats: ['iife'],
+            },
+            modulePreload: { polyfill: true },
+            commonjsOptions: {
+                exclude: ['mongodb/*'],
+                transformMixedEsModules: true,
+            },
+
+            rollupOptions: {
+                treeshake: 'smallest',
+                external: allExternal,
+                watch: false,
+                output: {
+                    dir: path.resolve(dir, 'dist/bundle'),
+                    entryFileNames: `${bundleName}.bundle.js`,
+                },
+
+                plugins: [
+                    css(),
+                    wasm(),
+                    nodeResolve({
+                        browser: true,
+                        preferBuiltins: false,
+                        rootDir: path.resolve(dir, '../../'),
+                        dedupe: ['react', 'react-dom'],
+                    }),
+                    // I think we can use this plugin to build all packages instead of relying on the tsc step that's
+                    // currently a precursor in package.json. However, it fails for the following reason:
+                    // https://github.com/rollup/plugins/issues/243
+                    // typescript({
+                    //     tsconfig: path.resolve('./tsconfig.json'),
+                    //     compilerOptions: { rootDir: path.resolve('./src') },
+                    // }),
+                ],
+            },
+        },
+        plugins: [
+            // Not sure if we need this plugin or not, it works without it
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            viteReact(),
+            viteCommonjs(),
+            // Closes the bundler and copies the bundle to the client-bundle-example project unless we're in serve
+            // mode, in which case we don't want to close the bundler because it will close the server
+            command !== 'serve' ? VitePluginCloseAndCopy(copyOptions) : undefined,
+            // Means we can specify index.tsx instead of index.jsx in the index.html file
+            viteTsconfigPaths({ projects: tsConfigPaths }),
+        ],
+    }
+}

package/src/vite/vite.test.config.ts

@@ -0,0 +1,29 @@
+import { defineConfig } from 'vitest/config'
+import VitePluginSourcemapExclude from './vite-plugin-sourcemap-exclude.js'
+
+export default function () {
+    return defineConfig({
+        build: {
+            minify: false,
+            sourcemap: false,
+            rollupOptions: {
+                maxParallelFileOps: 1,
+                cache: false,
+                output: {
+                    sourcemap: false,
+                },
+            },
+        },
+        test: {
+            include: ['../../packages/*/src/**/*.test.ts', '../../contracts/*/src/**/*.test.ts'],
+            exclude: ['../../demos/**/*'], // '../!packages/**/*'],
+            singleThread: true,
+            watchExclude: ['**/node_modules/**', '**/dist/**'],
+            logHeapUsage: true,
+            coverage: {
+                enabled: true,
+            },
+        },
+        plugins: [VitePluginSourcemapExclude({ excludeNodeModules: true })],
+    })
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tsconfig.esm.json",
+    "compilerOptions": {
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "types": ["vite/client"]
+    },
+    "include": ["./src/**/*.ts", "./src/**/*.d.ts", "./src/**/*.tsx"],
+    "references": [
+        {
+            "path": "../../packages/common"
+        },
+        {
+            "path": "../../packages/types"
+        }
+    ]
+}