quickbase-js 0.1.0-beta.7

package/tools/openapi-schema-validator.ts

@@ -0,0 +1,38 @@
+// tools/validate-spec.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import * as glob from "glob";
+import OpenAPISchemaValidator from "openapi-schema-validator";
+
+async function validateSpecs(): Promise<void> {
+  const CODEGEN_DIR = path.dirname(fileURLToPath(import.meta.url));
+  const SPLIT_DIR = path.join(CODEGEN_DIR, "..", "specs", "split");
+
+  const specFiles = glob.sync(path.join(SPLIT_DIR, "*.json"));
+  if (specFiles.length === 0) {
+    console.error("No split spec files found in specs/split/ folder.");
+    process.exit(1);
+  }
+
+  const validator = new OpenAPISchemaValidator({ version: 2 }); // Adjust based on spec version
+
+  for (const specFile of specFiles) {
+    console.log(`Validating ${path.basename(specFile)}...`);
+    const specContent = await fs.readFile(specFile, "utf8");
+    const spec = JSON.parse(specContent);
+
+    const result = validator.validate(spec);
+    if (result.errors.length > 0) {
+      console.error(`Validation errors in ${specFile}:`, result.errors);
+      process.exit(1);
+    } else {
+      console.log(`${specFile} is valid.`);
+    }
+  }
+}
+
+validateSpecs().catch((error) => {
+  console.error("Failed to validate specs:", error);
+  process.exit(1);
+});

package/tools/spec-analyzer.ts

@@ -0,0 +1,163 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import * as glob from "glob";
+
+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>;
+}
+
+interface TypeInference {
+  fieldId: string;
+  inferredType: string;
+  source: "schema" | "example";
+  confidence: number;
+  context: string;
+}
+
+interface AnalysisReport {
+  requestTypes: TypeInference[];
+  responseTypes: { [status: string]: TypeInference[] };
+  dynamicFields: TypeInference[];
+  errors: string[];
+}
+
+function inferTypeFromValue(value: any): string {
+  if (typeof value === "string") return "string";
+  if (typeof value === "number")
+    return Number.isInteger(value) ? "integer" : "number";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "any[]";
+    const itemTypes = value.map(inferTypeFromValue);
+    const uniqueTypes = [...new Set(itemTypes)];
+    return uniqueTypes.length === 1 ? `${uniqueTypes[0]}[]` : "any[]";
+  }
+  if (typeof value === "object" && value !== null) {
+    return "object";
+  }
+  return "any";
+}
+
+function analyzeDynamicFields(
+  schema: any,
+  analysis: AnalysisReport,
+  context: string
+) {
+  const examples = schema["x-amf-examples"];
+  if (examples) {
+    for (const [exampleName, example] of Object.entries(examples)) {
+      const data = example.value?.data;
+      if (Array.isArray(data)) {
+        data.forEach((record: any, index: number) => {
+          for (const [fieldId, fieldValue] of Object.entries(record)) {
+            const inferredType = inferTypeFromValue(fieldValue.value);
+            analysis.dynamicFields.push({
+              fieldId,
+              inferredType,
+              source: "example",
+              confidence: 0.8,
+              context: `${context}-example-${exampleName}-${index}`,
+            });
+          }
+        });
+      }
+    }
+  }
+
+  // Add schema-based type extraction logic
+  if (schema.properties?.data?.items) {
+    // Add logic to extract types from schema
+  }
+}
+
+function analyzeUpsertSpec(spec: Spec): AnalysisReport {
+  const upsertPath = spec.paths["/records"]?.post;
+  if (!upsertPath)
+    return {
+      errors: ["Upsert endpoint not found"],
+      requestTypes: [],
+      responseTypes: {},
+      dynamicFields: [],
+    };
+
+  const analysis: AnalysisReport = {
+    requestTypes: [],
+    responseTypes: { "200": [], "207": [] },
+    dynamicFields: [],
+    errors: [],
+  };
+
+  const requestSchema = upsertPath.parameters?.find(
+    (p) => p.in === "body"
+  )?.schema;
+  if (requestSchema) {
+    analyzeDynamicFields(requestSchema, analysis, "request");
+  }
+
+  for (const status of ["200", "207"]) {
+    const responseSchema = upsertPath.responses?.[status]?.schema;
+    if (responseSchema) {
+      analyzeDynamicFields(responseSchema, analysis, `response-${status}`);
+    }
+  }
+
+  return analysis;
+}
+
+async function runAnalysis() {
+  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, "..", "tools", "analysis");
+    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;
+    console.log(`Reading ${path.basename(inputFile)} from specs/...`);
+    const specContent = await fs.readFile(inputFile, "utf8");
+    const spec: Spec = JSON.parse(specContent);
+
+    const analysis = analyzeUpsertSpec(spec);
+    await fs.mkdir(OUTPUT_DIR, { recursive: true });
+    await fs.writeFile(
+      path.join(OUTPUT_DIR, "upsert-analysis.json"),
+      JSON.stringify(analysis, null, 2),
+      "utf8"
+    );
+    console.log(
+      "Analysis complete. Output written to:",
+      path.join(OUTPUT_DIR, "upsert-analysis.json")
+    );
+  } catch (error) {
+    console.error("Failed to analyze spec:", error);
+    process.exit(1);
+  }
+}
+
+runAnalysis();

package/tools/split-spec.ts

@@ -0,0 +1,148 @@
+// tools/split-spec.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import * as glob from "glob";
+
+interface Parameter {
+  name: string;
+  in: string;
+  required?: boolean;
+  type?: string;
+  schema?: any;
+  example?: any;
+  description?: string;
+}
+
+interface Operation {
+  parameters?: Parameter[];
+}
+
+interface Spec {
+  swagger?: string;
+  openapi?: string;
+  info: any;
+  paths: Record<string, Record<string, Operation>>;
+  definitions?: Record<string, any>;
+}
+
+function normalizeParameters(parameters: Parameter[] = []): Parameter[] {
+  return parameters.map((param) => {
+    const normalized: Parameter = {
+      name: param.name,
+      in: param.in,
+      required: param.required,
+      description: param.description,
+    };
+
+    // OpenAPI v2: 'body' parameters use 'schema', others use 'type'
+    if (param.in === "body") {
+      if (param.schema) {
+        normalized.schema = param.schema;
+      }
+    } else {
+      normalized.type = param.type || "string";
+      if (param.example !== undefined) {
+        delete param.example; // Remove 'example' as it’s not allowed in v2
+      }
+    }
+
+    // Ensure 'in' is valid
+    if (
+      !["query", "header", "path", "formData", "body"].includes(normalized.in)
+    ) {
+      console.warn(
+        `Invalid 'in' value '${normalized.in}' for parameter '${normalized.name}', defaulting to 'query'`
+      );
+      normalized.in = "query";
+    }
+
+    return normalized;
+  });
+}
+
+async function splitSpec(): Promise<void> {
+  const CODEGEN_DIR = path.dirname(fileURLToPath(import.meta.url));
+  const SPECS_DIR = path.join(CODEGEN_DIR, "..", "specs");
+  const OUTPUT_DIR = path.join(SPECS_DIR, "split");
+
+  // Find the latest spec file
+  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 specContent = await fs.readFile(inputFile, "utf8");
+  const spec: Spec = JSON.parse(specContent);
+
+  // Define categories based on endpoint paths
+  const categories: Record<string, string[]> = {
+    apps: Object.keys(spec.paths).filter((p) => p.startsWith("/apps")),
+    auth: Object.keys(spec.paths).filter((p) => p.startsWith("/auth")),
+    fields: Object.keys(spec.paths).filter((p) => p.startsWith("/fields")),
+    records: Object.keys(spec.paths).filter((p) => p.startsWith("/records")),
+    tables: Object.keys(spec.paths).filter((p) => p.startsWith("/tables")),
+    reports: Object.keys(spec.paths).filter((p) => p.startsWith("/reports")),
+    relationships: Object.keys(spec.paths).filter((p) =>
+      p.startsWith("/relationships")
+    ),
+    events: Object.keys(spec.paths).filter((p) => p.startsWith("/events")),
+  };
+
+  await fs.mkdir(OUTPUT_DIR, { recursive: true });
+
+  // Split spec by category
+  for (const [category, paths] of Object.entries(categories)) {
+    if (paths.length === 0) continue;
+
+    const categorySpec: Spec = {
+      swagger: "2.0", // OpenAPI v2
+      info: spec.info || { title: `${category} API`, version: "1.0.0" },
+      paths: {},
+      definitions: {},
+    };
+
+    // Add relevant paths and normalize parameters
+    for (const p of paths) {
+      const pathObj = { ...spec.paths[p] };
+      for (const method in pathObj) {
+        if (pathObj[method].parameters) {
+          pathObj[method].parameters = normalizeParameters(
+            pathObj[method].parameters
+          );
+        }
+      }
+      categorySpec.paths[p] = pathObj;
+    }
+
+    // Add relevant definitions
+    const refs = new Set<string>();
+    const refRegex = /#\/definitions\/([^"]+)/g;
+    const categorySpecString = JSON.stringify(categorySpec);
+    let match;
+    while ((match = refRegex.exec(categorySpecString))) {
+      refs.add(match[1]);
+    }
+    if (spec.definitions) {
+      for (const ref of refs) {
+        if (spec.definitions[ref]) {
+          categorySpec.definitions![ref] = spec.definitions[ref];
+        }
+      }
+    }
+
+    const outputFile = path.join(OUTPUT_DIR, `${category}.json`);
+    await fs.writeFile(
+      outputFile,
+      JSON.stringify(categorySpec, null, 2),
+      "utf8"
+    );
+    console.log(`Wrote ${outputFile}`);
+  }
+}
+
+splitSpec().catch((error) => {
+  console.error("Failed to split spec:", error);
+  process.exit(1);
+});

package/tools/test-import.ts

@@ -0,0 +1,3 @@
+// tools/test-import.ts
+import OpenAPISchemaValidator from "openapi-schema-validator";
+console.log(OpenAPISchemaValidator);

package/tools/validate-spec.ts

@@ -0,0 +1,40 @@
+// tools/validate-spec.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import * as glob from "glob";
+import OpenAPISchemaValidatorModule from "openapi-schema-validator";
+
+const OpenAPISchemaValidator = OpenAPISchemaValidatorModule.default;
+
+async function validateSpecs(): Promise<void> {
+  const CODEGEN_DIR = path.dirname(fileURLToPath(import.meta.url));
+  const SPLIT_DIR = path.join(CODEGEN_DIR, "..", "specs", "split");
+
+  const specFiles = glob.sync(path.join(SPLIT_DIR, "*.json"));
+  if (specFiles.length === 0) {
+    console.error("No split spec files found in specs/split/ folder.");
+    process.exit(1);
+  }
+
+  const validator = new OpenAPISchemaValidator({ version: 2 });
+
+  for (const specFile of specFiles) {
+    console.log(`Validating ${path.basename(specFile)}...`);
+    const specContent = await fs.readFile(specFile, "utf8");
+    const spec = JSON.parse(specContent);
+
+    const result = validator.validate(spec);
+    if (result.errors.length > 0) {
+      console.error(`Validation errors in ${specFile}:`, result.errors);
+      process.exit(1);
+    } else {
+      console.log(`${specFile} is valid.`);
+    }
+  }
+}
+
+validateSpecs().catch((error) => {
+  console.error("Failed to validate specs:", error);
+  process.exit(1);
+});

package/tsconfig.build.json

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/temp",
+    "noEmit": false,
+    "allowImportingTsExtensions": false,
+    "declaration": false,
+    "sourceMap": true
+  },
+  "include": ["dist/temp-src/**/*"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "tests/**/*",
+    "src/**/*" // Exclude original src/ to avoid confusion
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "lib": ["ES2015", "ESNext", "DOM"],
+    "types": ["node", "playwright/test", "undici-types"],
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "declaration": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"],
+      "@tests/*": ["tests/*"]
+    }
+  },
+  "include": ["src/**/*", "tests/**/*", "open-api/**/*", "tools/**/*"],
+  "exclude": ["node_modules", "dist/**/*", "generated/**/*", "specs"],
+  "ts-node": {
+    "esm": true,
+    "transpileOnly": true
+  }
+}

package/versionrc.json

@@ -0,0 +1,9 @@
+{
+  "types": [
+    { "type": "feat", "section": "Features" },
+    { "type": "fix", "section": "Bug Fixes" },
+    { "type": "docs", "section": "Documentation" },
+    { "type": "chore", "section": "Maintenance" }
+  ],
+  "prerelease": "beta"
+}

package/vitest.config.ts

@@ -0,0 +1,27 @@
+// vitest.config.ts
+import { defineConfig } from "vitest/config";
+import path from "path";
+import dotenv from "dotenv"; // Add this import
+
+// Load .env variables before tests run
+dotenv.config({ path: path.resolve(__dirname, ".env") });
+
+export default defineConfig({
+  test: {
+    environment: "jsdom",
+    include: ["tests/vitest/**/**/*.test.ts"],
+    setupFiles: ["tests/setup.ts"], // Relative path from root
+    pool: "forks",
+    poolOptions: {
+      forks: {
+        singleFork: true, // Run tests sequentially
+      },
+    },
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"), // For src/ imports
+      "@tests": path.resolve(__dirname, "./tests"), // For tests/ imports
+    },
+  },
+});