quickbase-js 0.1.0-beta.9 → 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/generateJsDoc.ts

@@ -1,96 +0,0 @@
-interface ParamDetail {
-  name: string;
-  type: string;
-  required: boolean;
-  properties: {
-    name: string;
-    type: string;
-    required: boolean;
-    jsdoc?: string;
-  }[];
-}
-
-interface JsDocOptions {
-  summary: string;
-  opId: string;
-  paramDetails: ParamDetail[];
-  returnType: string;
-  returnTypeDetails: {
-    name: string;
-    type: string;
-    required: boolean;
-    jsdoc?: string;
-  }[];
-  docLink: string;
-}
-
-export function generateJsDoc({
-  summary,
-  opId,
-  paramDetails,
-  returnType,
-  returnTypeDetails,
-  docLink,
-}: JsDocOptions): string {
-  const jsDocLines: string[] = [
-    `  /**`,
-    `   * ${summary}`,
-    `   *`,
-    `   * @param {Object} params _Object containing the parameters for_ ${opId}`,
-  ];
-
-  // Parameters section
-  if (paramDetails.length > 0) {
-    paramDetails.forEach((p) => {
-      jsDocLines.push(
-        `   *   @param {${p.type}} params.${p.name} _${
-          p.required ? "Required" : "Optional"
-        } parameter with properties_`
-      );
-      if (p.properties.length > 0) {
-        p.properties.forEach((prop) => {
-          const propDesc = prop.jsdoc
-            ? prop.jsdoc.replace(/@type\s*{[^}]+}\s*@memberof\s*\w+/, "").trim()
-            : `Type: ${prop.type}`;
-          jsDocLines.push(
-            `   *     - **${prop.name}** (\`${prop.type}\`${
-              prop.required ? ", required" : ", optional"
-            }) _${propDesc}_`
-          );
-        });
-      }
-    });
-  } else {
-    jsDocLines.push(`   *   No parameters`);
-  }
-
-  // Returns section
-  jsDocLines.push(`   *`);
-  if (returnTypeDetails.length > 0) {
-    jsDocLines.push(
-      `   * @returns {Promise<${returnType}>} _Promise resolving to the ${opId} response with properties_`
-    );
-    returnTypeDetails.forEach((prop) => {
-      const propDesc = prop.jsdoc
-        ? prop.jsdoc.replace(/@type\s*{[^}]+}\s*@memberof\s*\w+/, "").trim()
-        : `Type: ${prop.type}`;
-      jsDocLines.push(
-        `   *   - **${prop.name}** (\`${prop.type}\`${
-          prop.required ? ", required" : ", optional"
-        }) _${propDesc}_`
-      );
-    });
-  } else {
-    jsDocLines.push(
-      `   * @returns {Promise<${returnType}>} _Promise resolving to the ${opId} response_`
-    );
-  }
-
-  jsDocLines.push(
-    `   *`,
-    `   * @see {@link ${docLink}} Official Quickbase API documentation`
-  );
-  jsDocLines.push(`   */`);
-
-  return jsDocLines.join("\n");
-}

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;