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

package/open-api/definitions/index.ts

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

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

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

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

@@ -0,0 +1,112 @@
+// 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/{src/code-generation → open-api}/fix-spec-main.ts

@@ -3,8 +3,8 @@ import { promises as fs } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import * as glob from "glob";
-import { paths } from "./fix-spec-paths.ts";
-import { definitions } from "./fix-spec-definitions.ts";
+import { paths } from "./paths/index.ts";
+import { definitions } from "./definitions/index.ts";
 
 interface Parameter {
   name: string;
@@ -166,7 +166,7 @@ async function fixQuickBaseSpec(): Promise<void> {
     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!");
+    console.log("Spec fixed successfully! Output written to:", outputFile);
   } catch (error) {
     console.error("Failed to fix spec:", error);
     process.exit(1);

package/{src/code-generation → open-api}/generate-unified-interface.ts

@@ -1,15 +1,21 @@
-// src/code-generation/generate-unified-interface.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { simplifyName } from "../utils.ts";
 import { OpenAPIV2 } from "openapi-types";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const SPEC_FILE = join(__dirname, "output", "quickbase-fixed.json");
-const OUTPUT_DIR = join(__dirname, "..", "generated-unified");
+const SPEC_FILE = join(__dirname, "output", "quickbase-fixed.json"); // Remains relative to open-api/
+const OUTPUT_DIR = join(__dirname, "..", "src", "generated-unified"); // Updated to src/generated-unified/
 const OUTPUT_FILE = join(OUTPUT_DIR, "QuickbaseClient.ts");
 
+// Placeholder for simplifyName (since utils.ts is missing)
+function simplifyName(name: string): string {
+  return name
+    .replace(/ById$/, "")
+    .replace(/Api$/, "")
+    .replace(/^(\w)/, (_, c) => c.toLowerCase());
+}
+
 function generateInterface() {
   if (!existsSync(SPEC_FILE)) {
     console.error(
@@ -38,7 +44,7 @@ function generateInterface() {
       const op = operation as OpenAPIV2.OperationObject | undefined;
       if (!op || !op.operationId) continue;
 
-      const opId = op.operationId;
+      const opId = simplifyName(op.operationId);
       const params = (op.parameters || [])
         .filter((p) => {
           const param = p as OpenAPIV2.ParameterObject;
@@ -96,8 +102,13 @@ function generateInterface() {
   console.log(`Generated ${OUTPUT_FILE}`);
 }
 
-function mapOpenApiTypeToTs(openApiType: string): string {
-  switch (openApiType.toLowerCase()) {
+function mapOpenApiTypeToTs(
+  openApiType: string | string[] | undefined
+): string {
+  const type = Array.isArray(openApiType)
+    ? openApiType[0]
+    : openApiType || "any";
+  switch (type.toLowerCase()) {
     case "integer":
     case "int":
       return "number";
@@ -111,30 +122,44 @@ function mapOpenApiTypeToTs(openApiType: string): string {
 }
 
 function mapRefToType(
-  schema: OpenAPIV2.SchemaObject | OpenAPIV2.ReferenceObject,
+  schema: OpenAPIV2.SchemaObject | OpenAPIV2.ReferenceObject | undefined,
   modelImports: Set<string>
 ): string {
-  if ("$ref" in schema) {
+  if (!schema) return "any";
+
+  if ("$ref" in schema && schema.$ref) {
     const model = schema.$ref.split("/").pop()!;
     modelImports.add(model);
     return model;
   }
+
   if (schema.type === "array" && schema.items) {
     const itemType =
-      "$ref" in schema.items
+      "$ref" in schema.items && schema.items.$ref
         ? schema.items.$ref.split("/").pop()!
-        : mapOpenApiTypeToTs(schema.items.type || "any");
-    if ("$ref" in schema.items) modelImports.add(itemType);
+        : mapOpenApiTypeToTs(schema.items.type);
+    if ("$ref" in schema.items && schema.items.$ref) modelImports.add(itemType);
     return `${itemType}[]`;
   }
+
   if (schema.type === "object" && schema.additionalProperties) {
-    const valueType = schema.additionalProperties.$ref
-      ? schema.additionalProperties.$ref.split("/").pop()!
-      : mapOpenApiTypeToTs(schema.additionalProperties.type || "any");
-    if (schema.additionalProperties.$ref) modelImports.add(valueType);
+    const additionalProps = schema.additionalProperties as
+      | OpenAPIV2.SchemaObject
+      | OpenAPIV2.ReferenceObject
+      | boolean;
+    if (typeof additionalProps === "boolean") {
+      return "{ [key: string]: any }";
+    }
+    const valueType =
+      "$ref" in additionalProps && additionalProps.$ref
+        ? additionalProps.$ref.split("/").pop()!
+        : mapOpenApiTypeToTs(additionalProps.type);
+    if ("$ref" in additionalProps && additionalProps.$ref)
+      modelImports.add(valueType);
     return `{ [key: string]: ${valueType} }`;
   }
-  return mapOpenApiTypeToTs(schema.type || "any");
+
+  return mapOpenApiTypeToTs(schema.type);
 }
 
 try {