quickbase-js 0.1.0-beta.8 → 1.0.0

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

@@ -1,115 +0,0 @@
-// 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

@@ -1,211 +0,0 @@
-// 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

@@ -1,47 +0,0 @@
-// 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

@@ -1,42 +0,0 @@
-// open-api/types/spec.ts
-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>; // Required, no longer optional
-  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

@@ -1,40 +0,0 @@
-// 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

@@ -1,10 +0,0 @@
-// 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/playwright.config.ts

@@ -1,37 +0,0 @@
-// 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;

package/rollup.config.js

@@ -1,114 +0,0 @@
-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 typescript from "@rollup/plugin-typescript";
-
-const isProd = process.env.NODE_ENV === "production";
-
-// External dependencies for both ESM and UMD builds
-const external = [
-  "node:http",
-  "node:https",
-  "node:zlib",
-  "node:stream",
-  "node:buffer",
-  "node:util",
-  "node:url",
-  "node:net",
-  "node:fs",
-  "node:path",
-  "node-fetch",
-];
-
-// Global mappings for UMD (browser) build
-const globals = {
-  "node-fetch": "fetch", // Map node-fetch to window.fetch in browsers
-};
-
-export default [
-  // ESM Build
-  {
-    input: "src/quickbaseClient.ts",
-    output: {
-      dir: "dist/esm",
-      format: "esm",
-      sourcemap: true,
-      entryFileNames: "quickbase.js",
-    },
-    external,
-    plugins: [
-      nodeResolve({ preferBuiltins: true }), // Node.js resolution
-      commonjs(), // Convert CommonJS to ESM
-      typescript({
-        tsconfig: "./tsconfig.json",
-        noEmitOnError: true, // Fail on TypeScript errors
-        // Use Rollup to emit JavaScript, overriding noEmit for this build
-      }),
-      isProd && terser(), // Minification for production
-    ],
-  },
-  // UMD Build
-  {
-    input: "src/quickbaseClient.ts",
-    output: {
-      file: "dist/umd/quickbase.umd.js",
-      format: "umd",
-      name: "QuickbaseJS", // Global name for browser
-      sourcemap: true,
-      globals,
-    },
-    external,
-    plugins: [
-      nodeResolve({ preferBuiltins: true, browser: true }), // Browser-first resolution
-      commonjs(), // Convert CommonJS to UMD
-      typescript({
-        tsconfig: "./tsconfig.json",
-        noEmitOnError: true, // Fail on TypeScript errors
-        // Use Rollup to emit JavaScript, overriding noEmit for this build
-      }),
-      isProd && terser(), // Minification for production
-    ],
-  },
-  // ESM Declarations
-  {
-    input: "src/quickbaseClient.ts",
-    output: {
-      file: "dist/esm/quickbase.d.ts",
-      format: "esm",
-    },
-    plugins: [
-      dts({
-        tsconfig: "./tsconfig.json",
-        respectExternal: true, // Include external dependencies in declarations
-      }),
-    ],
-  },
-  // UMD Declarations
-  {
-    input: "src/quickbaseClient.ts",
-    output: {
-      file: "dist/umd/quickbase.umd.d.ts",
-      format: "umd",
-    },
-    plugins: [
-      dts({
-        tsconfig: "./tsconfig.json",
-        respectExternal: true, // Include external dependencies in declarations
-      }),
-    ],
-  },
-].map((config) => ({
-  ...config,
-  onwarn(warning, warn) {
-    // Suppress TypeScript plugin warnings
-    if (
-      warning.code === "PLUGIN_WARNING" &&
-      warning.plugin === "typescript" &&
-      warning.message.includes("TS5096")
-    ) {
-      return;
-    }
-    warn(warning);
-  },
-}));