quickbase-js 0.1.0-beta.7

package/open-api/schema/tags/records.ts

@@ -0,0 +1,115 @@
+// open-api/schema/tags/records.ts
+import { Operation, Parameter, Spec } from "../../types/spec.ts";
+import { normalizeDefinitionName } from "../../utils/naming.ts"; // Ensure this import is present
+
+export function enhanceRecords(
+  spec: Spec,
+  pathKey: string,
+  method: string,
+  operation: Operation
+): void {
+  const opId =
+    operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+  if (operation.parameters && operation.tags?.includes("Records")) {
+    operation.parameters.forEach((param: Parameter) => {
+      if (param.in === "body") {
+        if (!param.schema) param.schema = {};
+        let requestName =
+          param.schema.$ref?.split("/").pop() || `${opId}Request`;
+        requestName = normalizeDefinitionName(requestName);
+
+        if (
+          !spec.definitions[requestName] ||
+          !spec.definitions[requestName].type ||
+          Object.keys(spec.definitions[requestName]?.properties || {})
+            .length === 0
+        ) {
+          console.log(
+            `Defining schema for ${requestName} in ${pathKey}(${method})`
+          );
+          let properties;
+          // Upsert endpoint (/records)
+          if (pathKey === "/records" && method === "post") {
+            properties = {
+              data: { type: "array", items: { $ref: "#/definitions/Record" } },
+              to: { type: "string" },
+              fieldsToReturn: { type: "array", items: { type: "integer" } },
+            };
+          }
+          // Query endpoint (/records/query)
+          else if (pathKey === "/records/query" && method === "post") {
+            properties = {
+              from: { type: "string", description: "The table identifier." },
+              select: {
+                type: "array",
+                items: { type: "integer" },
+                description: "An array of field ids...",
+              },
+              where: {
+                type: "string",
+                description:
+                  "The filter, using the Quickbase query language...",
+              },
+              sortBy: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    fieldId: { type: "integer" },
+                    order: {
+                      type: "string",
+                      enum: ["ASC", "DESC", "equal-values"],
+                    },
+                  },
+                  required: ["fieldId", "order"],
+                },
+                description: "An array of field IDs and sort directions...",
+              },
+              groupBy: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    fieldId: { type: "integer" },
+                    grouping: { type: "string", enum: ["equal-values"] },
+                  },
+                  required: ["fieldId", "grouping"],
+                },
+                description:
+                  "An array that contains the fields to group the records by.",
+              },
+              options: {
+                type: "object",
+                properties: {
+                  skip: { type: "integer" },
+                  top: { type: "integer" },
+                  compareWithAppLocalTime: { type: "boolean" },
+                },
+                description: "Additional query options.",
+              },
+            };
+          }
+          // Delete endpoint (/records)
+          else if (method === "delete") {
+            properties = {
+              from: { type: "string" },
+              where: { type: "string" },
+            };
+          }
+          if (properties) {
+            spec.definitions[requestName] = {
+              type: "object",
+              properties,
+              required: ["from"], // Only 'from' is required per the spec
+              description: operation.summary || `Request body for ${opId}`,
+            };
+          }
+        }
+        param.schema = { $ref: `#/definitions/${requestName}` };
+        console.log(
+          `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+        );
+      }
+    });
+  }
+}

package/open-api/schema/tags/tables.ts

@@ -0,0 +1,211 @@
+// schema/tags/tables.ts
+import { Operation, Parameter, Spec } from "../../types/spec.ts";
+import { normalizeDefinitionName } from "../../utils/naming.ts";
+
+export function enhanceTables(
+  spec: Spec,
+  pathKey: string,
+  method: string,
+  operation: Operation
+): void {
+  const opId =
+    operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+  if (operation.parameters && operation.tags?.includes("Tables")) {
+    operation.parameters.forEach((param: Parameter) => {
+      if (param.in === "body") {
+        if (!param.schema) param.schema = {};
+        let requestName =
+          param.schema.$ref?.split("/").pop() || `${opId}Request`;
+        requestName = normalizeDefinitionName(requestName);
+
+        if (
+          !spec.definitions[requestName] ||
+          !spec.definitions[requestName].type ||
+          Object.keys(spec.definitions[requestName]?.properties || {})
+            .length === 0
+        ) {
+          console.log(
+            `Defining schema for ${requestName} in ${pathKey}(${method})`
+          );
+          let properties;
+
+          // Existing logic for other endpoints remains unchanged
+          if (pathKey === "/tables" && method === "post") {
+            properties = {
+              name: {
+                type: "string",
+                description: "The name for the table.",
+                minLength: 1,
+              },
+              description: {
+                type: "string",
+                description: "The description for the table...",
+              },
+              singleRecordName: {
+                type: "string",
+                description: "The singular noun for records...",
+              },
+              pluralRecordName: {
+                type: "string",
+                description: "The plural noun for records...",
+              },
+            };
+          } else if (pathKey === "/tables/{tableId}" && method === "post") {
+            properties = {
+              name: {
+                type: "string",
+                description: "The updated name of the table.",
+              },
+              description: {
+                type: "string",
+                description: "The updated description for the table.",
+              },
+            };
+          }
+          // Add minimal fix for relationship endpoints
+          else if (
+            pathKey === "/tables/{tableId}/relationship" &&
+            method === "post"
+          ) {
+            requestName = "CreateRelationshipRequest"; // Force correct name
+            if (!spec.definitions[requestName]) {
+              properties = {
+                parentTableId: {
+                  type: "string",
+                  description: "The parent table id for the relationship.",
+                },
+                foreignKeyField: {
+                  type: "object",
+                  properties: {
+                    label: {
+                      type: "string",
+                      description: "The label for the foreign key field.",
+                    },
+                  },
+                  additionalProperties: true,
+                },
+                lookupFieldIds: {
+                  type: "array",
+                  items: { type: "integer" },
+                  description: "Array of field ids...",
+                },
+                summaryFields: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      summaryFid: {
+                        type: "number",
+                        description: "The field id to summarize.",
+                      },
+                      label: {
+                        type: "string",
+                        description: "The label for the summary field.",
+                      },
+                      accumulationType: {
+                        type: "string",
+                        enum: [
+                          "AVG",
+                          "SUM",
+                          "MAX",
+                          "MIN",
+                          "STD-DEV",
+                          "COUNT",
+                          "COMBINED-TEXT",
+                          "COMBINED-USER",
+                          "DISTINCT-COUNT",
+                        ],
+                        description: "The accumulation type...",
+                      },
+                      where: { type: "string", description: "The filter..." },
+                    },
+                    required: ["accumulationType"],
+                    additionalProperties: true,
+                  },
+                  description: "Array of summary field objects...",
+                },
+              };
+            }
+          } else if (
+            pathKey === "/tables/{tableId}/relationship/{relationshipId}" &&
+            method === "post"
+          ) {
+            requestName = "UpdateRelationshipRequest"; // Force correct name
+            if (!spec.definitions[requestName]) {
+              properties = {
+                parentTableId: {
+                  type: "string",
+                  description: "The updated parent table id...",
+                },
+                foreignKeyField: {
+                  type: "object",
+                  properties: {
+                    label: {
+                      type: "string",
+                      description: "The updated label...",
+                    },
+                  },
+                  additionalProperties: true,
+                },
+                lookupFieldIds: {
+                  type: "array",
+                  items: { type: "integer" },
+                  description: "Updated array of field ids...",
+                },
+                summaryFields: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      summaryFid: { type: "number" },
+                      label: { type: "string" },
+                      accumulationType: {
+                        type: "string",
+                        enum: [
+                          "AVG",
+                          "SUM",
+                          "MAX",
+                          "MIN",
+                          "STD-DEV",
+                          "COUNT",
+                          "COMBINED-TEXT",
+                          "COMBINED-USER",
+                          "DISTINCT-COUNT",
+                        ],
+                      },
+                      where: { type: "string" },
+                    },
+                    required: ["accumulationType"],
+                    additionalProperties: true,
+                  },
+                },
+              };
+            }
+          }
+
+          if (properties) {
+            spec.definitions[requestName] = {
+              type: "object",
+              properties,
+              required:
+                pathKey.includes("relationship") &&
+                pathKey.endsWith("/relationship")
+                  ? ["parentTableId"]
+                  : pathKey === "/tables"
+                  ? ["name"]
+                  : [],
+              additionalProperties: pathKey.includes("relationship")
+                ? false
+                : true, // Match raw spec
+              description: operation.summary || `Request body for ${opId}`,
+            };
+          }
+        }
+        param.schema = { $ref: `#/definitions/${requestName}` };
+        console.log(
+          `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+        );
+      }
+    });
+  }
+}

package/open-api/schema/tags/users.ts

@@ -0,0 +1,47 @@
+// schema/tags/users.ts
+import { Operation, Parameter, Spec } from "../../types/spec.ts";
+import { normalizeDefinitionName } from "../../utils/naming.ts";
+
+export function enhanceUsers(
+  spec: Spec,
+  pathKey: string,
+  method: string,
+  operation: Operation
+): void {
+  const opId =
+    operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+  if (operation.parameters && operation.tags?.includes("Users")) {
+    operation.parameters.forEach((param: Parameter) => {
+      if (param.in === "body") {
+        if (!param.schema) param.schema = {};
+        let requestName =
+          param.schema.$ref?.split("/").pop() || `${opId}Request`;
+        requestName = normalizeDefinitionName(requestName);
+
+        if (
+          !spec.definitions[requestName] ||
+          !spec.definitions[requestName].type ||
+          Object.keys(spec.definitions[requestName]?.properties || {})
+            .length === 0
+        ) {
+          console.log(
+            `Defining schema for ${requestName} in ${pathKey}(${method})`
+          );
+          const properties = {
+            userIds: { type: "array", items: { type: "string" } },
+          };
+          spec.definitions[requestName] = {
+            type: "object",
+            properties,
+            required: Object.keys(properties),
+            description: operation.summary || `Request body for ${opId}`,
+          };
+        }
+        param.schema = { $ref: `#/definitions/${requestName}` };
+        console.log(
+          `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+        );
+      }
+    });
+  }
+}

package/open-api/types/spec.ts

@@ -0,0 +1,41 @@
+export interface Parameter {
+  name: string;
+  in: string;
+  required?: boolean;
+  type?: string;
+  schema?: {
+    type?: string;
+    items?: any;
+    $ref?: string;
+    properties?: any;
+    example?: any;
+  };
+  example?: any;
+}
+
+export interface Operation {
+  parameters?: Parameter[];
+  responses?: Record<
+    string,
+    { description: string; schema?: any; "x-amf-mediaType"?: string }
+  >;
+  operationId?: string;
+  summary?: string;
+  tags?: string[];
+}
+
+export interface Spec {
+  paths: Record<string, Record<string, Operation>>;
+  definitions?: Record<string, any>;
+  swagger: string;
+  info: any;
+  operations?: any;
+  groups?: any;
+  components?: any;
+}
+
+export interface FixSpecConfig {
+  applyOverrides?: boolean;
+  overridePaths?: string[];
+  overrideDefinitions?: string[];
+}

package/open-api/utils/infer-schema.ts

@@ -0,0 +1,40 @@
+// utils/infer-schema.ts
+export function inferSchema(example: any, operationId?: string): any {
+  if (!example || typeof example !== "object") {
+    return { type: "string" };
+  }
+  if (Array.isArray(example)) {
+    return {
+      type: "array",
+      items:
+        example.length > 0
+          ? inferSchema(example[0], operationId)
+          : { type: "string" },
+    };
+  }
+  const properties: Record<string, any> = {};
+  for (const [key, value] of Object.entries(example)) {
+    if (Array.isArray(value)) {
+      properties[key] = {
+        type: "array",
+        items:
+          value.length > 0
+            ? inferSchema(value[0], operationId)
+            : { type: "string" },
+      };
+    } else if (typeof value === "object" && value !== null) {
+      properties[key] = inferSchema(value, operationId);
+    } else {
+      properties[key] = {
+        type:
+          typeof value === "object" && value === null
+            ? "object"
+            : typeof value || "string",
+      };
+    }
+  }
+  if (operationId && operationId.endsWith("200Response")) {
+    return { type: "array", items: { type: "object", properties } };
+  }
+  return { type: "object", properties };
+}

package/open-api/utils/naming.ts

@@ -0,0 +1,10 @@
+// utils/naming.ts
+export function toCamelCase(str: string): string {
+  return str
+    .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
+    .replace(/^./, (str) => str.toLowerCase());
+}
+
+export function normalizeDefinitionName(name: string): string {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "quickbase-js",
+  "version": "0.1.0-beta.7",
+  "description": "QuickBase JavaScript client for frameworks and vanilla JS",
+  "type": "module",
+  "main": "dist/esm/quickbase.js",
+  "module": "dist/esm/quickbase.js",
+  "types": "dist/esm/quickbase.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/esm/quickbase.d.ts",
+      "import": {
+        "minified": "./dist/esm/quickbase.min.js",
+        "default": "./dist/esm/quickbase.js"
+      },
+      "require": {
+        "minified": "./dist/umd/quickbase.umd.min.js",
+        "default": "./dist/umd/quickbase.umd.js"
+      },
+      "umd:types": "./dist/umd/quickbase.umd.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "npm run build:esm && npm run build:umd",
+    "build:esm": "rimraf dist/esm dist/temp dist/temp-src && node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' build-esm.js",
+    "build:umd": "rimraf dist/umd dist/temp dist/temp-src && node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' build-umd.js",
+    "release": "standard-version",
+    "release:beta": "standard-version --prerelease beta",
+    "release:alpha": "standard-version --prerelease alpha",
+    "release:push": "npm run release:beta && git push --follow-tags origin main",
+    "release:publish": "npm run release:push && npm publish --tag beta",
+    "release:stable": "standard-version && git push --follow-tags origin main && npm publish",
+    "fix-spec": "node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' open-api/fix-spec-main.ts",
+    "gen:openapi": "rimraf src/generated && node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' open-api/regenerate-client.ts",
+    "gen:unified": "node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' open-api/generate-unified-interface.ts",
+    "gen:all": "npm run validate-spec && npm run fix-spec && npm run gen:openapi && npm run gen:unified",
+    "split-spec": "node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' tools/split-spec.ts",
+    "validate-spec": "node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' tools/validate-spec.ts",
+    "generate-types": "node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' tools/generate-types.ts",
+    "log-gen": "node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' tools/log-gen.ts",
+    "test:all": "vitest run tests/vitest/**/**/*.test.ts --reporter=basic && playwright test tests/playwright/qb --config playwright.config.ts --reporter=dot --quiet",
+    "test:pw:qb:all": "playwright test tests/playwright/qb --config playwright.config.ts",
+    "test:vitest:all": "vitest run tests/vitest/**/**/*.test.ts",
+    "test:vitest:qb": "vitest run tests/vitest/qb/**/*.test.ts",
+    "test:vitest:unit": "vitest run tests/vitest/unit/**/*.test.ts",
+    "test:vitest:qb:apps": "vitest run tests/vitest/qb/apps/*.test.ts",
+    "test:vitest:qb:auth": "vitest run tests/vitest/qb/auth/*.test.ts",
+    "test:vitest:qb:fields": "vitest run tests/vitest/qb/fields/*.test.ts",
+    "test:vitest:qb:records": "vitest run tests/vitest/qb/records/*.test.ts",
+    "test:vitest:qb:tables": "vitest run tests/vitest/qb/tables/*.test.ts",
+    "test:vitest:unit:apps": "vitest run tests/vitest/unit/apps/*.test.ts",
+    "test:vitest:unit:auth": "vitest run tests/vitest/unit/auth/*.test.ts",
+    "test:vitest:unit:fields": "vitest run tests/vitest/unit/fields/*.test.ts",
+    "test:vitest:unit:records": "vitest run tests/vitest/unit/records/*.test.ts",
+    "test:vitest:unit:tables": "vitest run tests/vitest/unit/tables/*.test.ts",
+    "test:pw:qb:auth": "playwright test tests/playwright/qb/auth"
+  },
+  "dependencies": {
+    "typescript": "^4.8.2"
+  },
+  "devDependencies": {
+    "@openapitools/openapi-generator-cli": "^1.17.0",
+    "@playwright/test": "^0.51.0",
+    "@rollup/plugin-commonjs": "^27.0.3",
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "@rollup/plugin-terser": "^-1.4.4",
+    "@rollup/plugin-typescript": "^11.1.2",
+    "@types/js-yaml": "^3.0.9",
+    "@types/node": "^21.13.10",
+    "dotenv": "^15.4.7",
+    "glob": "^10.0.1",
+    "js-yaml": "^3.1.0",
+    "jsdom": "^25.0.0",
+    "node-fetch": "^2.3.2",
+    "openapi-schema-validator": "^11.1.3",
+    "openapi-types": "^11.1.3",
+    "openapi-typescript": "^6.6.1",
+    "rimraf": "^4.0.10",
+    "rollup": "^3.35.0",
+    "rollup-plugin-dts": "^5.1.1",
+    "standard-version": "^8.5.0",
+    "ts-morph": "^24.0.1",
+    "ts-node": "^9.9.2",
+    "tslib": "^1.8.1",
+    "undici-types": "^6.5.0",
+    "vitest": "^2.0.8"
+  }
+}

package/playwright.config.ts

@@ -0,0 +1,37 @@
+// playwright.config.ts
+import { defineConfig, devices } from "@playwright/test";
+
+const config = defineConfig({
+  fullyParallel: true,
+  workers: undefined, // Default: half of CPU cores (e.g., 2 on a 4-core machine)
+  // workers: 2, // Or explicitly set to 2 for controlled testing
+  testDir: "./tests/playwright",
+  timeout: 600000, // 10 minutes
+  retries: 2,
+  reporter: [
+    ["list"],
+    ["json", { outputFile: "test-artifacts/test-results.json" }],
+  ],
+  use: {
+    baseURL: "https://api.quickbase.com",
+    headless: true,
+    viewport: { width: 1280, height: 720 },
+    actionTimeout: 10000,
+    screenshot: "off",
+  },
+  outputDir: "test-artifacts",
+  projects: [
+    {
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] },
+    },
+  ],
+});
+
+console.log(
+  `Loading Playwright: Testing temp token authorization in browser. Be patient, this could take at least 5min. Workers: ${
+    config.workers || "default (half CPU cores)"
+  }`
+);
+
+export default config;