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

package/open-api/paths/apps.ts

@@ -0,0 +1,100 @@
+// src/code-generation/paths/apps.ts
+export const appsPaths = {
+  "/apps": {
+    post: {
+      operationId: "createApp",
+      summary: "Create a new application",
+      tags: ["Apps"],
+      parameters: [
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: { $ref: "#/definitions/CreateAppRequest" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - application created",
+          schema: { $ref: "#/definitions/CreateApp200Response" },
+        },
+      },
+    },
+  },
+  "/apps/{appId}": {
+    get: {
+      operationId: "getApp",
+      summary: "Get an app by ID",
+      tags: ["Apps"],
+      parameters: [
+        {
+          name: "appId",
+          in: "path",
+          required: true,
+          type: "string",
+          description: "The application identifier.",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: { $ref: "#/definitions/App" },
+        },
+      },
+    },
+    delete: {
+      operationId: "deleteApp",
+      summary: "Delete an application by ID",
+      tags: ["Apps"],
+      parameters: [
+        {
+          name: "appId",
+          in: "path",
+          required: true,
+          type: "string",
+          description: "The unique identifier of the app to delete.",
+        },
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: { $ref: "#/definitions/DeleteAppRequest" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - application deleted",
+          schema: { $ref: "#/definitions/DeleteApp200Response" },
+        },
+      },
+    },
+  },
+  "/apps/{appId}/copy": {
+    post: {
+      operationId: "copyApp",
+      summary: "Copy an existing application",
+      tags: ["Apps"],
+      parameters: [
+        {
+          name: "appId",
+          in: "path",
+          required: true,
+          type: "string",
+          description: "The unique identifier of the app to copy.",
+        },
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: { $ref: "#/definitions/CopyAppRequest" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - application copied",
+          schema: { $ref: "#/definitions/CopyApp200Response" },
+        },
+      },
+    },
+  },
+};

package/open-api/paths/auth.ts

@@ -0,0 +1,25 @@
+// src/code-generation/paths/auth.ts
+export const authPaths = {
+  "/auth/temporary/{dbid}": {
+    get: {
+      operationId: "getTempTokenDBID",
+      summary: "Get a temporary authorization token for a specific dbid",
+      tags: ["Auth"],
+      parameters: [
+        {
+          name: "dbid",
+          in: "path",
+          required: true,
+          type: "string",
+          description: "The database identifier (dbid).",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: { $ref: "#/definitions/GetTempTokenDBID200Response" },
+        },
+      },
+    },
+  },
+};

package/open-api/paths/fields.ts

@@ -0,0 +1,207 @@
+// src/code-generation/paths/fields.ts
+export const fieldsPaths = {
+  "/fields": {
+    get: {
+      operationId: "getFields",
+      summary: "Get all fields for a table",
+      tags: ["Fields"],
+      parameters: [
+        {
+          name: "tableId",
+          in: "query",
+          required: true,
+          type: "string",
+          description: "The table identifier (dbid).",
+        },
+        {
+          name: "includeFieldPerms",
+          in: "query",
+          required: false,
+          type: "boolean",
+          description: "Whether to include field permissions.",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/Field" },
+          },
+        },
+      },
+    },
+    post: {
+      operationId: "createField",
+      summary: "Create a new field in a table",
+      tags: ["Fields"],
+      parameters: [
+        {
+          name: "tableId",
+          in: "query",
+          required: true,
+          type: "string",
+          description: "The unique identifier of the table.",
+        },
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: { $ref: "#/definitions/CreateFieldRequest" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - field created",
+          schema: { $ref: "#/definitions/CreateField200Response" },
+        },
+      },
+    },
+    delete: {
+      operationId: "deleteFields",
+      summary: "Delete fields from a table",
+      tags: ["Fields"],
+      parameters: [
+        {
+          name: "tableId",
+          in: "query",
+          required: true,
+          type: "string",
+          description: "The unique identifier of the table.",
+        },
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: { $ref: "#/definitions/DeleteFieldsRequest" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - fields deleted, with possible errors",
+          schema: { $ref: "#/definitions/DeleteFields200Response" },
+        },
+      },
+    },
+  },
+  "/fields/{fieldId}": {
+    get: {
+      operationId: "getField",
+      summary: "Get the properties of an individual field by ID",
+      tags: ["Fields"],
+      parameters: [
+        {
+          name: "fieldId",
+          in: "path",
+          required: true,
+          type: "integer",
+          description: "The unique identifier (fid) of the field.",
+        },
+        {
+          name: "tableId",
+          in: "query",
+          required: true,
+          type: "string",
+          description: "The unique identifier (dbid) of the table.",
+        },
+        {
+          name: "includeFieldPerms",
+          in: "query",
+          required: false,
+          type: "boolean",
+          description:
+            "Set to 'true' to include custom permissions for the field.",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - field properties retrieved",
+          schema: { $ref: "#/definitions/Field" },
+        },
+      },
+    },
+  },
+  "/fields/usage": {
+    get: {
+      operationId: "getFieldsUsage",
+      summary: "Get usage statistics for all fields in a table",
+      tags: ["Fields"],
+      parameters: [
+        {
+          name: "tableId",
+          in: "query",
+          required: true,
+          type: "string",
+          description: "The unique identifier (dbid) of the table.",
+        },
+        {
+          name: "skip",
+          in: "query",
+          required: false,
+          type: "integer",
+          description: "The number of fields to skip from the list.",
+        },
+        {
+          name: "top",
+          in: "query",
+          required: false,
+          type: "integer",
+          description: "The maximum number of fields to return.",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - field usage statistics retrieved",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/FieldUsage" },
+          },
+        },
+      },
+    },
+  },
+  "/fields/usage/{fieldId}": {
+    get: {
+      operationId: "getFieldUsage",
+      summary: "Get usage statistics for a single field",
+      description:
+        "Retrieve usage statistics for a specific field, summarizing where it is referenced across QuickBase features such as reports, forms, and pipelines.",
+      tags: ["Fields"],
+      parameters: [
+        {
+          name: "fieldId",
+          in: "path",
+          required: true,
+          type: "integer",
+          description: "The unique identifier (fid) of the field.",
+        },
+        {
+          name: "tableId",
+          in: "query",
+          required: true,
+          type: "string",
+          description:
+            "The unique identifier (dbid) of the table containing the field.",
+        },
+        {
+          name: "User-Agent",
+          in: "header",
+          required: false,
+          type: "string",
+          description:
+            "Identifies the client making the request. Can be custom or default from your toolkit.",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - field usage statistics retrieved",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/FieldUsage" },
+            maxItems: 1, // Ensures a single-item array as per QuickBase API behavior
+          },
+        },
+      },
+    },
+  },
+};

package/open-api/paths/index.ts

@@ -0,0 +1,17 @@
+import { appsPaths } from "./apps.ts";
+import { authPaths } from "./auth.ts";
+import { fieldsPaths } from "./fields.ts";
+import { recordsPaths } from "./records.ts";
+import { relationshipsPaths } from "./relationships.ts";
+import { reportsPaths } from "./reports.ts";
+import { tablesPaths } from "./tables.ts";
+
+export const paths = {
+  ...appsPaths,
+  ...authPaths,
+  ...fieldsPaths,
+  ...recordsPaths,
+  ...relationshipsPaths,
+  ...reportsPaths,
+  ...tablesPaths,
+};

package/open-api/paths/records.ts

@@ -0,0 +1,68 @@
+// src/code-generation/paths/records.ts
+export const recordsPaths = {
+  "/records": {
+    post: {
+      operationId: "upsert",
+      summary: "Upsert records in a table",
+      tags: ["Records"],
+      parameters: [
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: { $ref: "#/definitions/UpsertRequest" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - all records processed successfully",
+          schema: { $ref: "#/definitions/Upsert200Response" },
+        },
+        207: {
+          description: "Multi-Status - partial success with some errors",
+          schema: { $ref: "#/definitions/Upsert207Response" },
+        },
+      },
+    },
+    delete: {
+      operationId: "deleteRecords",
+      summary: "Delete records in a table",
+      tags: ["Records"],
+      parameters: [
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: { $ref: "#/definitions/DeleteRecordsRequest" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - records deleted",
+          schema: { $ref: "#/definitions/DeleteRecords200Response" },
+        },
+      },
+    },
+  },
+  "/records/query": {
+    post: {
+      operationId: "runQuery",
+      summary: "Query records in a table",
+      tags: ["Records"],
+      parameters: [
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: { $ref: "#/definitions/RunQueryRequest" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - records returned",
+          schema: { $ref: "#/definitions/RunQueryResponse" },
+        },
+      },
+    },
+  },
+};

package/open-api/paths/relationships.ts

@@ -0,0 +1,32 @@
+// src/code-generation/paths/relationships.ts
+export const relationshipsPaths = {
+  "/tables/{tableId}/relationships": {
+    get: {
+      operationId: "getRelationships",
+      summary: "Get relationships for a table",
+      tags: ["Relationships"],
+      parameters: [
+        {
+          name: "tableId",
+          in: "path",
+          required: true,
+          type: "string",
+          description: "The unique identifier (dbid) of the child table.",
+        },
+        {
+          name: "skip",
+          in: "query",
+          required: false,
+          type: "integer",
+          description: "The number of relationships to skip.",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - relationships retrieved",
+          schema: { $ref: "#/definitions/GetRelationships200Response" },
+        },
+      },
+    },
+  },
+};

package/open-api/paths/reports.ts

@@ -0,0 +1,34 @@
+// src/code-generation/paths/reports.ts
+export const reportsPaths = {
+  "/reports/{reportId}/run": {
+    post: {
+      operationId: "runReport",
+      summary: "Run a report",
+      tags: ["Reports"],
+      parameters: [
+        {
+          name: "reportId",
+          in: "path",
+          required: true,
+          type: "string",
+          description: "The report identifier.",
+        },
+        {
+          name: "generated",
+          in: "body",
+          required: true,
+          schema: { type: "object" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/ReportRunResponse" },
+          },
+        },
+      },
+    },
+  },
+};

package/open-api/paths/tables.ts

@@ -0,0 +1,162 @@
+// src/code-generation/paths/tables.ts
+export const tablesPaths = {
+  "/tables": {
+    get: {
+      operationId: "getAppTables",
+      summary: "Get all tables for an app",
+      tags: ["Tables"],
+      parameters: [
+        {
+          name: "appId",
+          in: "query",
+          required: true,
+          type: "string",
+          description: "The application identifier.",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/Table" },
+          },
+        },
+      },
+    },
+    post: {
+      operationId: "createTable",
+      summary: "Create a new table in an app",
+      tags: ["Tables"],
+      parameters: [
+        {
+          name: "appId",
+          in: "query",
+          required: true,
+          type: "string",
+          description:
+            "The unique identifier of the app where the table will be created.",
+        },
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: {
+            type: "object",
+            properties: {
+              name: { type: "string", description: "The name of the table." },
+              description: {
+                type: "string",
+                description: "The description of the table.",
+              },
+              singleRecordName: {
+                type: "string",
+                description: "Singular noun for records.",
+              },
+              pluralRecordName: {
+                type: "string",
+                description: "Plural noun for records.",
+              },
+            },
+            required: ["name"],
+          },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - table created",
+          schema: { $ref: "#/definitions/Table" },
+        },
+      },
+    },
+  },
+  "/tables/{tableId}": {
+    get: {
+      operationId: "getTable",
+      summary: "Get a table by ID",
+      tags: ["Tables"],
+      parameters: [
+        {
+          name: "tableId",
+          in: "path",
+          required: true,
+          type: "string",
+          description: "The table identifier (dbid).",
+        },
+        {
+          name: "appId",
+          in: "query",
+          required: true,
+          type: "string",
+          description: "The unique identifier of the app containing the table.",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - table retrieved",
+          schema: { $ref: "#/definitions/Table" },
+        },
+      },
+    },
+    post: {
+      operationId: "updateTable",
+      summary: "Update a table by ID",
+      tags: ["Tables"],
+      parameters: [
+        {
+          name: "tableId",
+          in: "path",
+          required: true,
+          type: "string",
+          description: "The table identifier (dbid).",
+        },
+        {
+          name: "appId",
+          in: "query",
+          required: true,
+          type: "string",
+          description: "The unique identifier of the app containing the table.",
+        },
+        {
+          name: "body",
+          in: "body",
+          required: true,
+          schema: { $ref: "#/definitions/UpdateTableRequest" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - table updated",
+          schema: { $ref: "#/definitions/Table" },
+        },
+      },
+    },
+    delete: {
+      operationId: "deleteTable",
+      summary: "Delete a table by ID",
+      tags: ["Tables"],
+      parameters: [
+        {
+          name: "tableId",
+          in: "path",
+          required: true,
+          type: "string",
+          description: "The table identifier (dbid).",
+        },
+        {
+          name: "appId",
+          in: "query",
+          required: true,
+          type: "string",
+          description: "The unique identifier of the app containing the table.",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success - table deleted",
+          schema: { $ref: "#/definitions/DeleteTableResponse" },
+        },
+      },
+    },
+  },
+};

package/{src/code-generation → open-api}/regenerate-client.ts

@@ -9,10 +9,10 @@ import readline from "readline";
 const CURRENT_JAR_VERSION = "7.12.0";
 const MAVEN_METADATA_URL =
   "https://repo1.maven.org/maven2/org/openapitools/openapi-generator-cli/maven-metadata.xml";
-const CODEGEN_DIR = join(fileURLToPath(import.meta.url), "..");
-const JARS_DIR = join(CODEGEN_DIR, "..", "openapi-jars");
-const SPEC_INPUT = join(CODEGEN_DIR, "output", "quickbase-fixed.json"); // Updated path
-const OUTPUT_DIR = join(CODEGEN_DIR, "..", "generated");
+const CODEGEN_DIR = join(fileURLToPath(import.meta.url), ".."); // open-api/
+const JARS_DIR = join(CODEGEN_DIR, "..", "tools", "openapi-jars"); // Updated to tools/openapi-jars/
+const SPEC_INPUT = join(CODEGEN_DIR, "output", "quickbase-fixed.json"); // Relative to open-api/
+const OUTPUT_DIR = join(CODEGEN_DIR, "..", "src", "generated"); // Up to root, then into src/generated/
 
 async function getLatestVersion(): Promise<string> {
   const response = await fetch(MAVEN_METADATA_URL);