quickbase-js 1.1.0-beta.5 → 1.1.0

package/open-api/definitions/index.ts

@@ -1,18 +0,0 @@
-// src/code-generation/definitions/index.ts
-import { appsDefinitions } from "./apps.ts";
-import { authDefinitions } from "./auth.ts";
-import { fieldsDefinitions } from "./fields.ts";
-import { recordsDefinitions } from "./records.ts";
-import { relationshipsDefinitions } from "./relationships.ts";
-import { reportsDefinitions } from "./reports.ts";
-import { tablesDefinitions } from "./tables.ts";
-
-export const definitions = {
-  ...appsDefinitions,
-  ...authDefinitions,
-  ...fieldsDefinitions,
-  ...recordsDefinitions,
-  ...relationshipsDefinitions,
-  ...reportsDefinitions,
-  ...tablesDefinitions,
-};

package/open-api/definitions/records.ts

@@ -1,269 +0,0 @@
-// src/code-generation/definitions/records.ts
-export const recordsDefinitions = {
-  Record: {
-    type: "object",
-    properties: {
-      _dummy: {
-        type: "string",
-        description: "Unused dummy property to force model generation.",
-        nullable: true,
-      },
-    },
-    additionalProperties: {
-      type: "object",
-      properties: {
-        value: {
-          anyOf: [
-            { type: "string" },
-            { type: "number" },
-            { type: "boolean" },
-            { type: "object" },
-            { type: "array" },
-            { type: "null" },
-          ],
-          description: "The value of the field.",
-        },
-      },
-      required: ["value"],
-      description: "The value object for a field ID key.",
-    },
-    description:
-      "A record with field ID keys (e.g., '6') and value objects (e.g., { value: 'data' }).",
-  },
-  UpsertRequest: {
-    type: "object",
-    required: ["to"],
-    properties: {
-      to: { type: "string", description: "The table identifier (dbid)." },
-      data: {
-        type: "array",
-        items: { $ref: "#/definitions/Record" },
-        description: "Array of records to upsert.",
-      },
-      mergeFieldId: {
-        type: "integer",
-        description: "The field ID to merge on (optional).",
-      },
-      fieldsToReturn: {
-        type: "array",
-        items: { type: "integer" },
-        description: "Field IDs to return in the response (optional).",
-      },
-    },
-  },
-  Upsert200Response: {
-    type: "object",
-    properties: {
-      data: {
-        type: "array",
-        items: {
-          type: "object",
-          additionalProperties: {
-            type: "object",
-            properties: {
-              value: {
-                anyOf: [
-                  { type: "string" },
-                  { type: "number" },
-                  { type: "boolean" },
-                  { type: "object" },
-                  { type: "array" },
-                  { type: "null" },
-                ],
-                description: "The value of the field.",
-              },
-            },
-            required: ["value"],
-          },
-        },
-        description: "Array of upserted records with field IDs and values.",
-      },
-      metadata: {
-        type: "object",
-        properties: {
-          createdRecordIds: {
-            type: "array",
-            items: { type: "integer" },
-            description: "IDs of newly created records.",
-          },
-          updatedRecordIds: {
-            type: "array",
-            items: { type: "integer" },
-            description: "IDs of updated records.",
-          },
-          unchangedRecordIds: {
-            type: "array",
-            items: { type: "integer" },
-            description: "IDs of unchanged records.",
-          },
-          totalNumberOfRecordsProcessed: {
-            type: "integer",
-            description: "Total records processed.",
-          },
-        },
-        required: ["totalNumberOfRecordsProcessed"],
-      },
-    },
-  },
-  Upsert207Response: {
-    type: "object",
-    properties: {
-      data: {
-        type: "array",
-        items: {
-          type: "object",
-          additionalProperties: {
-            type: "object",
-            properties: {
-              value: {
-                anyOf: [
-                  { type: "string" },
-                  { type: "number" },
-                  { type: "boolean" },
-                  { type: "object" },
-                  { type: "array" },
-                  { type: "null" },
-                ],
-                description: "The value of the field.",
-              },
-            },
-            required: ["value"],
-          },
-        },
-        description: "Array of successfully upserted records (may be empty).",
-      },
-      metadata: {
-        type: "object",
-        properties: {
-          createdRecordIds: { type: "array", items: { type: "integer" } },
-          updatedRecordIds: { type: "array", items: { type: "integer" } },
-          unchangedRecordIds: { type: "array", items: { type: "integer" } },
-          lineErrors: {
-            type: "object",
-            additionalProperties: { type: "array", items: { type: "string" } },
-            description: "Errors by line number (1-based index).",
-          },
-          totalNumberOfRecordsProcessed: { type: "integer" },
-        },
-        required: ["totalNumberOfRecordsProcessed"],
-      },
-    },
-  },
-  DeleteRecordsRequest: {
-    type: "object",
-    required: ["from", "where"],
-    properties: {
-      from: {
-        type: "string",
-        description:
-          "The table identifier (dbid) from which to delete records.",
-      },
-      where: {
-        type: "string",
-        description:
-          "A QuickBase query string specifying which records to delete.",
-      },
-    },
-    description:
-      "Request body for deleting records from a table using a query.",
-  },
-  DeleteRecords200Response: {
-    type: "object",
-    properties: {
-      numberDeleted: {
-        type: "integer",
-        description: "The number of records successfully deleted.",
-      },
-    },
-    required: ["numberDeleted"],
-    description: "Response body for successful deletion of records.",
-  },
-  RunQueryRequest: {
-    type: "object",
-    required: ["from"],
-    properties: {
-      from: { type: "string", description: "Table ID (dbid)" },
-      select: {
-        type: "array",
-        items: { type: "integer" },
-        description: "Field IDs to return",
-      },
-      where: { type: "string", description: "Query string" },
-      sortBy: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            fieldId: { type: "integer" },
-            order: { type: "string", enum: ["ASC", "DESC"] },
-          },
-        },
-        description: "Sort criteria",
-      },
-      groupBy: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            fieldId: { type: "integer" },
-            grouping: { type: "string", enum: ["equal-values"] },
-          },
-        },
-        description: "Grouping criteria",
-      },
-      options: {
-        type: "object",
-        properties: {
-          skip: { type: "integer", description: "Number of records to skip" },
-          top: {
-            type: "integer",
-            description: "Max number of records to return",
-          },
-          compareWithAppLocalTime: {
-            type: "boolean",
-            description: "Compare times with app local time",
-          },
-        },
-      },
-    },
-  },
-  RunQueryResponse: {
-    type: "object",
-    properties: {
-      data: {
-        type: "array",
-        items: {
-          type: "object",
-          additionalProperties: {
-            type: "object",
-            properties: { value: { type: "any" } },
-          },
-        },
-        description: "Array of record data with field IDs as keys",
-      },
-      fields: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: { type: "integer" },
-            label: { type: "string" },
-            type: { type: "string" },
-          },
-        },
-        description: "Field metadata",
-      },
-      metadata: {
-        type: "object",
-        properties: {
-          numFields: { type: "integer" },
-          numRecords: { type: "integer" },
-          skip: { type: "integer" },
-          top: { type: "integer" },
-          totalRecords: { type: "integer" },
-        },
-        description: "Query metadata",
-      },
-    },
-  },
-};

package/open-api/definitions/relationships.ts

@@ -1,90 +0,0 @@
-// src/code-generation/definitions/relationships.ts
-export const relationshipsDefinitions = {
-  GetRelationships200Response: {
-    type: "object",
-    properties: {
-      metadata: {
-        type: "object",
-        properties: {
-          numRelationships: {
-            type: "integer",
-            description:
-              "The number of relationships in the current response object.",
-          },
-          skip: {
-            type: "integer",
-            description: "The number of relationships skipped.",
-          },
-          totalRelationships: {
-            type: "integer",
-            description: "The total number of relationships.",
-          },
-        },
-        required: ["numRelationships", "skip", "totalRelationships"],
-        description:
-          "Additional information about the results that may be helpful.",
-      },
-      relationships: {
-        type: "array",
-        items: { $ref: "#/definitions/Relationship" },
-        description: "The relationships in a table.",
-      },
-    },
-    required: ["metadata", "relationships"],
-    description: "Response containing relationships for a table.",
-  },
-  Relationship: {
-    type: "object",
-    properties: {
-      id: {
-        type: "integer",
-        description: "The relationship id (foreign key field id).",
-      },
-      parentTableId: {
-        type: "string",
-        description: "The parent table id of the relationship.",
-      },
-      childTableId: {
-        type: "string",
-        description: "The child table id of the relationship.",
-      },
-      foreignKeyField: {
-        $ref: "#/definitions/RelationshipField",
-        description: "The foreign key field information.",
-      },
-      isCrossApp: {
-        type: "boolean",
-        description: "Whether this is a cross-app relationship.",
-      },
-      lookupFields: {
-        type: "array",
-        items: { $ref: "#/definitions/RelationshipField" },
-        description: "The lookup fields array.",
-      },
-      summaryFields: {
-        type: "array",
-        items: { $ref: "#/definitions/RelationshipField" },
-        description: "The summary fields array.",
-      },
-    },
-    required: [
-      "id",
-      "parentTableId",
-      "childTableId",
-      "foreignKeyField",
-      "isCrossApp",
-    ],
-    description: "A relationship between tables.",
-  },
-  RelationshipField: {
-    type: "object",
-    properties: {
-      id: { type: "integer", description: "Field id." },
-      label: { type: "string", description: "Field label." },
-      type: { type: "string", description: "Field type." },
-    },
-    required: ["id", "label", "type"],
-    description:
-      "A field involved in a relationship (foreign key, lookup, or summary).",
-  },
-};

package/open-api/definitions/reports.ts

@@ -1,10 +0,0 @@
-// src/code-generation/definitions/reports.ts
-export const reportsDefinitions = {
-  ReportRunResponse: {
-    type: "object",
-    properties: {
-      id: { type: "string" },
-      data: { type: "object" },
-    },
-  },
-};

package/open-api/definitions/tables.ts

@@ -1,112 +0,0 @@
-// src/code-generation/definitions/tables.ts
-export const tablesDefinitions = {
-  Table: {
-    type: "object",
-    required: ["id", "name"],
-    properties: {
-      id: {
-        type: "string",
-        description: "The unique identifier (dbid) of the table.",
-      },
-      name: { type: "string", description: "The name of the table." },
-      alias: {
-        type: "string",
-        description: "The automatically-created table alias for the table.",
-      },
-      description: {
-        type: "string",
-        description:
-          "The description of the table, as configured by an application administrator.",
-      },
-      created: {
-        type: "string",
-        format: "date-time",
-        description:
-          "The time and date when the table was created, in ISO 8601 format (UTC).",
-      },
-      updated: {
-        type: "string",
-        format: "date-time",
-        description:
-          "The time and date when the table schema or data was last updated, in ISO 8601 format (UTC).",
-      },
-      nextRecordId: {
-        type: "integer",
-        description:
-          "The incremental Record ID that will be used when the next record is created.",
-      },
-      nextFieldId: {
-        type: "integer",
-        description:
-          "The incremental Field ID that will be used when the next field is created.",
-      },
-      defaultSortFieldId: {
-        type: "integer",
-        description:
-          "The id of the field that is configured for default sorting.",
-      },
-      defaultSortOrder: {
-        type: "string",
-        enum: ["ASC", "DESC"],
-        description:
-          "The default sort order for the table, either ascending (ASC) or descending (DESC).",
-      },
-      keyFieldId: {
-        type: "integer",
-        description:
-          "The id of the field that is configured to be the key on this table, usually the Quickbase Record ID.",
-      },
-      singleRecordName: {
-        type: "string",
-        description: "The builder-configured singular noun of the table.",
-      },
-      pluralRecordName: {
-        type: "string",
-        description: "The builder-configured plural noun of the table.",
-      },
-      sizeLimit: {
-        type: "string",
-        description: "The size limit for the table (e.g., '150 MB').",
-      },
-      spaceUsed: {
-        type: "string",
-        description:
-          "The amount of space currently being used by the table (e.g., '17 MB').",
-      },
-      spaceRemaining: {
-        type: "string",
-        description:
-          "The amount of space remaining for use by the table (e.g., '133 MB').",
-      },
-    },
-  },
-  UpdateTableRequest: {
-    type: "object",
-    properties: {
-      name: { type: "string", description: "The new name for the table." },
-      singleRecordName: {
-        type: "string",
-        description:
-          "The new singular noun for records in the table. Defaults to 'Record' if not provided.",
-      },
-      pluralRecordName: {
-        type: "string",
-        description:
-          "The new plural noun for records in the table. Defaults to 'Records' if not provided.",
-      },
-      description: {
-        type: "string",
-        description:
-          "The new description for the table. Defaults to blank if not provided.",
-      },
-    },
-    description:
-      "Request body for updating table properties. At least one property must be provided.",
-  },
-  DeleteTableResponse: {
-    type: "object",
-    properties: {
-      deletedTableId: { type: "string", description: "The deleted table id." },
-    },
-  },
-};

package/open-api/fix-spec-main.ts

@@ -1,176 +0,0 @@
-#!/usr/bin/env node
-import { promises as fs } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import * as glob from "glob";
-import { paths } from "./paths/index.ts";
-import { definitions } from "./definitions/index.ts";
-
-interface Parameter {
-  name: string;
-  in: string;
-  required?: boolean;
-  type?: string;
-  schema?: { type?: string; items?: any; $ref?: string; properties?: any };
-  example?: any;
-}
-
-interface Operation {
-  parameters?: Parameter[];
-  responses?: Record<string, { description: string; schema?: any }>;
-  operationId?: string;
-  summary?: string;
-  tags?: string[];
-}
-
-interface Spec {
-  paths: Record<string, Record<string, Operation>>;
-  definitions?: Record<string, any>;
-  operations?: any;
-  groups?: any;
-  components?: any;
-}
-
-function toCamelCase(str: string): string {
-  return str
-    .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
-    .replace(/^./, (str) => str.toLowerCase());
-}
-
-function fixArraySchemas(spec: Spec) {
-  for (const pathKey in spec.paths) {
-    for (const method in spec.paths[pathKey]) {
-      const operation = spec.paths[pathKey][method];
-      if (operation.parameters) {
-        operation.parameters.forEach((param: Parameter) => {
-          if (param.schema) {
-            if (param.schema.type === "array" && !param.schema.items) {
-              console.log(
-                `Fixing missing items in ${pathKey}(${method}).${param.name}`
-              );
-              param.schema.items =
-                pathKey === "/records" && param.name === "generated"
-                  ? { $ref: "#/definitions/Record" }
-                  : { type: "string" };
-            }
-            if (param.schema.properties) {
-              for (const propKey in param.schema.properties) {
-                const prop = param.schema.properties[propKey];
-                if (prop.type === "array" && !prop.items) {
-                  console.log(
-                    `Fixing nested array in ${pathKey}(${method}).${param.name}.${propKey}`
-                  );
-                  prop.items =
-                    propKey === "data" && pathKey === "/records"
-                      ? { $ref: "#/definitions/Record" }
-                      : { type: "string" };
-                }
-              }
-            }
-          }
-        });
-      }
-      if (operation.responses) {
-        for (const status in operation.responses) {
-          const response = operation.responses[status];
-          if (response.schema) {
-            if (response.schema.type === "array" && !response.schema.items) {
-              console.log(
-                `Fixing missing items in ${pathKey}(${method}).responses.${status}`
-              );
-              response.schema.items =
-                pathKey === "/records"
-                  ? { $ref: "#/definitions/Upsert200Response" }
-                  : { type: "string" };
-            }
-            if (response.schema.properties) {
-              for (const propKey in response.schema.properties) {
-                const prop = response.schema.properties[propKey];
-                if (prop.type === "array" && !prop.items) {
-                  console.log(
-                    `Fixing nested array in ${pathKey}(${method}).responses.${status}.${propKey}`
-                  );
-                  prop.items =
-                    propKey === "data" && pathKey === "/records"
-                      ? { $ref: "#/definitions/Upsert200Response" }
-                      : { type: "string" };
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-async function fixQuickBaseSpec(): Promise<void> {
-  try {
-    const CODEGEN_DIR = path.dirname(fileURLToPath(import.meta.url));
-    const SPECS_DIR = path.join(CODEGEN_DIR, "..", "specs");
-    const OUTPUT_DIR = path.join(CODEGEN_DIR, "output");
-    console.log("Finding latest QuickBase RESTful API spec...");
-    const specFiles = glob.sync(
-      path.join(SPECS_DIR, "QuickBase_RESTful_*.json")
-    );
-    if (specFiles.length === 0) {
-      console.error(
-        "No QuickBase_RESTful_*.json files found in specs/ folder."
-      );
-      process.exit(1);
-    }
-    const inputFile = specFiles.sort().pop() as string;
-    const outputFile = path.join(OUTPUT_DIR, "quickbase-fixed.json");
-
-    console.log(`Reading ${path.basename(inputFile)} from specs/...`);
-    const specContent = await fs.readFile(inputFile, "utf8");
-    const spec: Spec = JSON.parse(specContent);
-
-    console.log("Fixing parameters...");
-    for (const pathKey in spec.paths) {
-      for (const method in spec.paths[pathKey]) {
-        const operation = spec.paths[pathKey][method];
-        if (operation.parameters) {
-          operation.parameters = operation.parameters
-            .filter(
-              (param) =>
-                !["QB-Realm-Hostname", "Authorization", "User-Agent"].includes(
-                  param.name
-                )
-            )
-            .map((param: Parameter) => {
-              param.name = toCamelCase(param.name);
-              if ("example" in param) delete param.example;
-              if ("schema" in param && param.in !== "body") delete param.schema;
-              if (!param.type && param.in !== "body") param.type = "string";
-              return param;
-            });
-        }
-      }
-    }
-
-    console.log("Applying endpoint fixes...");
-    spec.paths = { ...spec.paths, ...paths }; // Merge original and custom paths
-
-    console.log("Fixing array schemas...");
-    fixArraySchemas(spec);
-
-    console.log("Applying definitions...");
-    spec.definitions = { ...spec.definitions, ...definitions }; // Merge definitions
-
-    console.log("Removing unexpected top-level attributes...");
-    delete spec.operations;
-    delete spec.groups;
-    delete spec.components;
-
-    console.log(`Writing fixed spec to ${path.basename(outputFile)}...`);
-    await fs.mkdir(OUTPUT_DIR, { recursive: true });
-    await fs.writeFile(outputFile, JSON.stringify(spec, null, 2), "utf8");
-    console.log("Spec fixed successfully! Output written to:", outputFile);
-  } catch (error) {
-    console.error("Failed to fix spec:", error);
-    process.exit(1);
-  }
-}
-
-fixQuickBaseSpec();