quickbase-js 1.1.0-beta.4 → 1.1.0-beta.5

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [1.1.0-beta.5](https://github.com/DrewBradfordXYZ/quickbase-js/compare/v1.1.0-beta.4...v1.1.0-beta.5) (2025-03-13)
+
+
+### Features
+
+* ESM and UMD build prod ([49513e9](https://github.com/DrewBradfordXYZ/quickbase-js/commit/49513e902e7bf4dd35da3c6508242e96507a91bd))
+* ESM and UMD support and src folder reorganization ([dc0170b](https://github.com/DrewBradfordXYZ/quickbase-js/commit/dc0170b547e6e9e57a117fbcccfdbeb86e48a8c7))
+
 ## [1.1.0-beta.4](https://github.com/DrewBradfordXYZ/quickbase-js/compare/v1.1.0-beta.3...v1.1.0-beta.4) (2025-03-12)
 
 

package/README.md

@@ -67,6 +67,60 @@ npm run build
 npm run test:all
 ```
 
+## Usage
+
+### Node.js (ESM - Recommended)
+
+For modern Node.js applications, use ES modules:
+
+```javascript
+// ESM (Node.js) - Recommended
+import { quickbase } from "quickbase-js";
+const qb = quickbase({ realm: "example", userToken: "your-token" });
+
+// Example: Fetching an app
+const app = await qb.getApp({ appId: "your-app-id" });
+console.log(app);
+
+// Example: Creating a record with temporary token
+const qbTemp = quickbase({ realm: "example", useTempTokens: true });
+const record = await qbTemp.upsert({
+  body: {
+    to: "your-table-id",
+    data: [
+      {
+        /* record data */
+      },
+    ],
+  },
+});
+console.log(record);
+```
+
+```javascript
+// Example: TypeScript ESM (Recommended)
+import { quickbase } from "quickbase-js";
+const qbTyped: QuickbaseClient = quickbase({
+  realm: "example",
+  userToken: "your-token",
+});
+const typedApp = await qbTyped.getApp({ appId: "your-app-id" });
+console.log(typedApp);
+```
+
+```javascript
+// Example: UMD via CDN (QuickBase Code Pages)
+// Note: This is HTML, not JavaScript, and should be used in a browser environment
+
+<script src="https://cdn.jsdelivr.net/npm/quickbase-js@1.1.0-beta.4/dist/umd/quickbase.umd.js"></script>
+<script>
+  const qb = new QuickbaseJS({ realm: 'example', useTempTokens: true });
+  // Example: Fetching an app
+  qb.getApp({ appId: 'your-app-id' }).then(app => console.log(app));
+</script>
+
+```
+
 ## In QuickBase Code Pages (Browser Environment)
 
 ### useTempTokens: true:

package/build.js

@@ -1,66 +1,186 @@
-#!/usr/bin/env node
-const { readFile, writeFile } = require("fs/promises");
-const { execSync } = require("child_process");
-const esbuild = require("esbuild");
-const pkg = require("./package.json");
+import { execSync } from 'child_process';
+import { rollup } from 'rollup';
+import terser from '@rollup/plugin-terser';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import dts from 'rollup-plugin-dts';
+import { rimrafSync } from 'rimraf';
+import { copyFileSync, readdirSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'fs';
+import { join } from 'path';
 
-async function build() {
-  try {
-    // Compile TypeScript
-    console.log("Compiling TypeScript...");
-    execSync("npx tsc -b", { stdio: "inherit" });
+// Clean the dist folder
+rimrafSync('dist');
+rimrafSync('dist/temp-src');
 
-    // Format with Prettier
-    console.log("Formatting files with Prettier...");
-    execSync("npx prettier --write src/**/*.ts dist/**/*.js", {
-      stdio: "inherit",
-    });
+// Step 1: Copy runtime-relevant files from src/ to dist/temp-src and remove .ts extensions
+const srcDir = join(process.cwd(), 'src');
+const tempSrcDir = join(process.cwd(), 'dist/temp-src');
+const runtimeDirs = ['generated', 'generated-unified'];
+const runtimeFiles = ['index.ts', 'quickbaseClient.ts', 'tokenCache.ts'];
 
-    // Bundle for Browser
-    console.log("Bundling for Browser...");
-    await esbuild.build({
-      entryPoints: ["dist/QuickBaseClient.js"],
-      bundle: true,
-      minify: true,
+function copyAndRewriteTsExtensions(src, dest) {
+  console.log(`Copying from ${src} to ${dest}`);
+  mkdirSync(dest, { recursive: true });
+  const files = readdirSync(src, { withFileTypes: true });
+  for (const file of files) {
+    const srcPath = join(src, file.name);
+    const destPath = join(dest, file.name);
+    if (file.isDirectory()) {
+      if (runtimeDirs.includes(file.name) || runtimeDirs.some(dir => src.includes(dir))) {
+        copyAndRewriteTsExtensions(srcPath, destPath);
+      } else {
+        console.log(`Skipping non-runtime directory ${srcPath}`);
+      }
+    } else if (file.name.endsWith('.ts')) {
+      if (runtimeFiles.includes(file.name) || src.includes('generated') || src.includes('generated-unified')) {
+        console.log(`Processing ${srcPath} -> ${destPath}`);
+        let content = readFileSync(srcPath, 'utf8');
+        content = content.replace(/(from\s+["']\.[\w\/-]+)\.ts(["'])/g, '$1$2');
+        content = content.replace(/(export\s+\*\s+from\s+["']\.[\w\/-]+)\.ts(["'])/g, '$1$2');
+        writeFileSync(destPath, content, 'utf8');
+      } else {
+        console.log(`Skipping non-runtime file ${srcPath}`);
+      }
+    } else {
+      console.log(`Skipping non-.ts file ${srcPath}`);
+    }
+  }
+}
+copyAndRewriteTsExtensions(srcDir, tempSrcDir);
+
+// Step 2: Compile TypeScript to JavaScript with tsc
+console.log('Running tsc...');
+const tsFiles = readdirSync(tempSrcDir, { recursive: true })
+  .filter(file => file.endsWith('.ts'))
+  .map(file => join(tempSrcDir, file));
+const tscCommand = `npx tsc ${tsFiles.join(' ')} --outDir ${join(process.cwd(), 'dist/temp')} --module ESNext --target ESNext --sourceMap --moduleResolution bundler --baseUrl ${process.cwd()}`;
+console.log(`Command: ${tscCommand}`);
+execSync(tscCommand, { stdio: 'inherit' });
+
+// Step 3: Rollup configuration
+const isProd = process.env.NODE_ENV === 'production';
+const external = [
+  'node:http', 'node:https', 'node:zlib', 'node:stream', 'node:buffer',
+  'node:util', 'node:url', 'node:net', 'node:fs', 'node:path', 'node-fetch',
+];
+const globals = { 'node-fetch': 'fetch' };
+
+// Function to create Rollup bundle
+async function createBundle(input, plugins, format, outputOptions) {
+  const bundle = await rollup({
+    input,
+    external,
+    plugins,
+  });
+  await bundle.write(outputOptions);
+  await bundle.close();
+}
+
+// ESM Builds
+console.log('Building ESM bundles...');
+// Unminified ESM build (always generated)
+await createBundle(
+  'dist/temp/quickbaseClient.js',
+  [
+    nodeResolve({ preferBuiltins: true }),
+    commonjs(),
+  ],
+  'esm',
+  {
+    dir: 'dist/esm',
+    format: 'esm',
+    sourcemap: true,
+    entryFileNames: 'quickbase.js',
+  }
+);
+
+// Minified ESM build (only in production)
+if (isProd) {
+  await createBundle(
+    'dist/temp/quickbaseClient.js',
+    [
+      nodeResolve({ preferBuiltins: true }),
+      commonjs(),
+      terser(),
+    ],
+    'esm',
+    {
+      dir: 'dist/esm',
+      format: 'esm',
       sourcemap: true,
-      target: ["es2015"],
-      outfile: "dist/quickbase-client.browser.min.js",
-    });
+      entryFileNames: 'quickbase.min.js',
+    }
+  );
+}
 
-    // Load Sources
-    console.log("Loading Sources...");
-    const browserSource = await readFile(
-      "dist/quickbase-client.browser.min.js",
-      "utf8"
-    );
-    const cjsSource = await readFile("dist/QuickBaseClient.js", "utf8");
-    const license = await readFile("LICENSE", "utf8");
+// UMD Builds
+console.log('Building UMD bundles...');
+// Unminified UMD build (always generated)
+await createBundle(
+  'dist/temp/quickbaseClient.js',
+  [
+    nodeResolve({ preferBuiltins: true, browser: true }),
+    commonjs(),
+  ],
+  'umd',
+  {
+    file: join(process.cwd(), 'dist/umd', 'quickbase.umd.js'),
+    format: 'umd',
+    name: 'QuickbaseJS',
+    sourcemap: true,
+    globals,
+  }
+);
+
+// Minified UMD build (only in production)
+if (isProd) {
+  await createBundle(
+    'dist/temp/quickbaseClient.js',
+    [
+      nodeResolve({ preferBuiltins: true, browser: true }),
+      commonjs(),
+      terser(),
+    ],
+    'umd',
+    {
+      file: join(process.cwd(), 'dist/umd', 'quickbase.umd.min.js'),
+      format: 'umd',
+      name: 'QuickbaseJS',
+      sourcemap: true,
+      globals,
+    }
+  );
+}
 
-    // Build Header
-    console.log("Adding Metadata...");
-    const header = [
-      "/*! ",
-      ` * ${pkg.name} v${pkg.version}`,
-      ` * ${pkg.description || "A QuickBase API Client"}`,
-      ` * License: ${pkg.license}`,
-      ` * ${license}`,
-      " */",
-    ].join("\n");
+// Declarations
+console.log('Generating declarations...');
+const dtsBundle = await rollup({
+  input: 'src/quickbaseClient.ts',
+  plugins: [dts({ tsconfig: './tsconfig.json', respectExternal: true })],
+});
+await dtsBundle.write({ file: 'dist/esm/quickbase.d.ts', format: 'esm' });
+await dtsBundle.write({ file: 'dist/umd/quickbase.umd.d.ts', format: 'umd' });
+await dtsBundle.close();
 
-    // Write Output Files
-    await Promise.all([
-      writeFile(
-        "dist/quickbase-client.browser.min.js",
-        header + "\n" + browserSource
-      ),
-      writeFile("dist/QuickBaseClient.js", header + "\n" + cjsSource),
-    ]);
+// Clean up
+rimrafSync('dist/temp');
+rimrafSync('dist/temp-src');
 
-    console.log("Build completed successfully.");
-  } catch (error) {
-    console.error("Build failed:", error);
-    process.exit(1);
+// List generated files and their sizes
+console.log('\nGenerated files:');
+function listFilesWithSizes(dir, prefix = '') {
+  const files = readdirSync(dir, { withFileTypes: true });
+  for (const file of files) {
+    const filePath = join(dir, file.name);
+    if (file.isDirectory()) {
+      listFilesWithSizes(filePath, `${prefix}${file.name}/`);
+    } else {
+      const stats = statSync(filePath);
+      const sizeKB = (stats.size / 1024).toFixed(2);
+      console.log(`${prefix}${file.name} - ${sizeKB} KB`);
+    }
   }
 }
+listFilesWithSizes(join(process.cwd(), 'dist'));
 
-build();
+console.log('\nBuild completed successfully');