chore(deps): upgrade @ftrack/api + make it runnable without esbuild (#51)

Author: jimmycallin

package.json

@@ -16,7 +16,7 @@
     "prepublish": "yarn test"
   },
   "dependencies": {
-    "@ftrack/api": "^1.4.5",
+    "@ftrack/api": "^1.11.3-rc.1",
     "prettier": "^3.5.3"
   },
   "files": [
@@ -33,7 +33,6 @@
   "devDependencies": {
     "@eslint/js": "^9.22.0",
     "@types/node": "^22.13.10",
-    "@types/ws": "^8.18.0",
     "@typescript-eslint/utils": "^8.26.1",
     "@vitest/eslint-plugin": "^1.1.37",
     "esbuild": "^0.25.1",

source/emit.test.ts

@@ -6,11 +6,19 @@ import {
   type Status,
   type Type,
   emitToString,
-} from "./emit";
-import type { QuerySchemasResponse, Schema } from "@ftrack/api";
+} from "./emit.ts";
+import type { Schema as ApiSchema } from "./session.ts";
+import { type QuerySchemasResponse, type Schema } from "@ftrack/api";
 import { readFile } from "fs/promises";
 import { join } from "path";
-import type { CustomAttributeConfiguration } from "./emitCustomAttributes";
+import type { CustomAttributeConfiguration } from "./emitCustomAttributes.ts";
+
+vi.mock("@ftrack/api", (importOriginal) => {
+  return {
+    ...importOriginal,
+    Session: class Session {},
+  };
+});
 
 beforeEach(() => {
   vi.setSystemTime(new Date(2023, 1, 1, 0, 0, 0));
@@ -50,7 +58,7 @@ test("schema subtype of TypedContext", async () => {
   const emitResult = await emitToString(
     "4.13.8",
     "https://ftrack.example.com",
-    schemas as QuerySchemasResponse,
+    schemas as QuerySchemasResponse<ApiSchema>,
     [],
     [],
     [],
@@ -84,7 +92,7 @@ test("schema has base schema", async () => {
   const emitResult = await emitToString(
     "4.13.8",
     "https://ftrack.example.com",
-    schemas as QuerySchemasResponse,
+    schemas as QuerySchemasResponse<ApiSchema>,
     [],
     [],
     [],
@@ -119,7 +127,7 @@ test("schema has immutable property", async () => {
   const emitResult = await emitToString(
     "4.13.8",
     "https://ftrack.example.com",
-    schemas as QuerySchemasResponse,
+    schemas as QuerySchemasResponse<ApiSchema>,
     [],
     [],
     [],
@@ -153,7 +161,7 @@ test("schema has integer type", async () => {
   const emitResult = await emitToString(
     "4.13.8",
     "https://ftrack.example.com",
-    schemas as QuerySchemasResponse,
+    schemas as QuerySchemasResponse<ApiSchema>,
     [],
     [],
     [],
@@ -187,7 +195,7 @@ test("schema has variable type", async () => {
   const emitResult = await emitToString(
     "4.13.8",
     "https://ftrack.example.com",
-    schemas as QuerySchemasResponse,
+    schemas as QuerySchemasResponse<ApiSchema>,
     [],
     [],
     [],
@@ -234,7 +242,7 @@ test("schema has array type", async () => {
   const emitResult = await emitToString(
     "4.13.8",
     "https://ftrack.example.com",
-    schemas as QuerySchemasResponse,
+    schemas as QuerySchemasResponse<ApiSchema>,
     [],
     [],
     [],
@@ -262,7 +270,7 @@ test("default highway test (all values specified)", async () => {
     ),
   );
 
-  const schemas = await parseJsonFromFile<Schema[]>(
+  const schemas = await parseJsonFromFile<QuerySchemasResponse<ApiSchema>>(
     join(".", "source", "__snapshots__", "responses", "query_schemas.json"),
   );
 

source/emit.ts

@@ -1,28 +1,28 @@
-import type { QuerySchemasResponse, Session } from "@ftrack/api";
+import type { QuerySchemasResponse } from "@ftrack/api";
 import * as fs from "fs";
 import * as path from "path";
 import {
   type CustomAttributeConfiguration,
   emitCustomAttributes,
-} from "./emitCustomAttributes.js";
-import { emitSchemaInterface } from "./emitSchema.js";
-import { TypeScriptEmitter } from "./typescriptEmitter.js";
-import { isSchemaTypedContext } from "./utils.js";
+} from "./emitCustomAttributes.ts";
+import { emitSchemaInterface } from "./emitSchema.ts";
+import { TypeScriptEmitter } from "./typescriptEmitter.ts";
+import { isSchemaTypedContext } from "./utils.ts";
+import { session, type Schema } from "./session.ts";
 
 const legacySchemas = ["Conversation", "Message", "Participant"];
 export async function emitToFile(
-  session: Session,
   outputPath = "__generated__",
   outputFilename = "schema.ts",
 ) {
   // Get the schemas from the server and sort by id in alphabetical order
-  const schemas = await getSchemas(session);
-  const customAttributes = await getCustomAttributes(session);
-  const types = await getTypes(session);
-  const objectTypes = await getObjectTypes(session);
-  const projectSchemas = await getProjectSchemas(session);
-  const statuses = await getStatuses(session);
-  const priorities = await getPriorities(session);
+  const schemas = await getSchemas();
+  const customAttributes = await getCustomAttributes();
+  const types = await getTypes();
+  const objectTypes = await getObjectTypes();
+  const projectSchemas = await getProjectSchemas();
+  const statuses = await getStatuses();
+  const priorities = await getPriorities();
 
   const { prettifiedContent, errors } = await emitToString(
     session.serverVersion,
@@ -109,7 +109,7 @@ export type Status = {
 export async function emitToString(
   serverVersion: string | undefined,
   serverUrl: string | undefined,
-  schemas: QuerySchemasResponse,
+  schemas: QuerySchemasResponse<Schema>,
   customAttributes: CustomAttributeConfiguration[],
   types: Type[],
   objectTypes: ObjectType[],
@@ -275,15 +275,15 @@ export async function emitToString(
   };
 }
 
-async function getCustomAttributes(session: Session) {
-  const customAttributes = await session.query<CustomAttributeConfiguration>(
+async function getCustomAttributes() {
+  const customAttributes = await session.query<"CustomAttributeConfiguration">(
     "select default, label, key, project_id, entity_type, is_hierarchical, object_type.name, type.name from CustomAttributeConfiguration order by sort",
   );
   return customAttributes.data;
 }
 
-async function getSchemas(session: Session) {
-  const schemas = await session.call<QuerySchemasResponse>([
+async function getSchemas() {
+  const schemas = await session.call<QuerySchemasResponse<Schema>>([
     {
       action: "query_schemas",
     },
@@ -292,44 +292,44 @@ async function getSchemas(session: Session) {
   return schemas[0];
 }
 
-async function getTypes(session: Session) {
-  const types = await session.query<Type>(
+async function getTypes() {
+  const types = await session.query<"Type">(
     "select is_billable, name, task_type_schemas from Type order by sort",
   );
   return types.data;
 }
 
-async function getPriorities(session: Session) {
-  const priorities = await session.query<Priority>(
+async function getPriorities() {
+  const priorities = await session.query<"Priority">(
     "select id, color, name, sort, value from Priority order by sort",
   );
   return priorities.data;
 }
 
-async function getStatuses(session: Session) {
-  const priorities = await session.query<Status>(
+async function getStatuses() {
+  const priorities = await session.query<"Status">(
     "select id, color, is_active, name, sort, state from Status order by sort",
   );
   return priorities.data;
 }
 
-async function getObjectTypes(session: Session) {
-  const objectTypes = await session.query<ObjectType>(
+async function getObjectTypes() {
+  const objectTypes = await session.query<"ObjectType">(
     "select id, is_leaf, is_prioritizable, is_schedulable, is_statusable, is_taskable, is_time_reportable, is_typeable, name, project_schemas from ObjectType order by sort",
   );
   return objectTypes.data;
 }
 
-async function getProjectSchemas(session: Session) {
-  const projectSchemas = await session.query<ProjectSchema>(
+async function getProjectSchemas() {
+  const projectSchemas = await session.query<"ProjectSchema">(
     "select name, asset_version_workflow_schema, name, object_type_schemas, object_types, task_templates, task_type_schema, task_workflow_schema, task_workflow_schema_overrides from ProjectSchema",
   );
   return projectSchemas.data;
 }
 
 function emitTypedContextTypes(
   builder: TypeScriptEmitter,
-  schemas: QuerySchemasResponse,
+  schemas: QuerySchemasResponse<Schema>,
 ) {
   builder.appendCode(`
     export interface TypedContextSubtypeMap {

source/emitCustomAttributes.ts

@@ -1,5 +1,6 @@
 import type { QuerySchemasResponse } from "@ftrack/api";
-import { TypeScriptEmitter } from "./typescriptEmitter";
+import { TypeScriptEmitter } from "./typescriptEmitter.ts";
+import type { Schema } from "./session.ts";
 
 const uniq = <T>(array: T[]): T[] => {
   return Array.from(new Set(array));
@@ -21,7 +22,7 @@ const groupBy = <T, K extends string>(list: T[], getKey: (item: T) => K) => {
 
 export function emitCustomAttributes(
   typescriptEmitter: TypeScriptEmitter,
-  schemas: QuerySchemasResponse,
+  schemas: QuerySchemasResponse<Schema>,
   customAttributes: CustomAttributeConfiguration[],
 ) {
   typescriptEmitter.appendCode(`

source/emitSchema.ts

@@ -1,18 +1,19 @@
 // :copyright: Copyright (c) 2023 ftrack
 import type {
   QuerySchemasResponse,
-  Schema,
   SchemaProperties,
   TypedSchemaProperty,
+  Schema,
 } from "@ftrack/api";
-import { type TypeScriptEmitter } from "./typescriptEmitter";
-import { isSchemaTypedContext } from "./utils";
+import { type TypeScriptEmitter } from "./typescriptEmitter.ts";
+import { isSchemaTypedContext } from "./utils.ts";
+import type { Schema as ApiSchema } from "./session.ts";
 
 // Add schemas from the schemas folder, to be used for finding extended schemas
 export async function emitSchemaInterface(
   typescriptEmitter: TypeScriptEmitter,
   schema: Schema,
-  allSchemas: QuerySchemasResponse,
+  allSchemas: QuerySchemasResponse<ApiSchema>,
 ) {
   const interfaceName = getTypeScriptInterfaceNameForInterface(schema);
 

source/index.ts

@@ -1,23 +1,10 @@
 #!/usr/bin/env node
 // :copyright: Copyright (c) 2023 ftrack
-// A node.js script to convert our query_schema to TypeScript types
-// TODO: Change type to module in API
-import { Session } from "@ftrack/api";
-import { emitToFile } from "./emit";
-
-const session = new Session(
-  process.env.FTRACK_SERVER ?? "",
-  process.env.FTRACK_API_USER ?? "",
-  process.env.FTRACK_API_KEY ?? "",
-);
+import { emitToFile } from "./emit.ts";
 
 const outputPath = process.argv[2] || "__generated__";
 const outputFilename = process.argv[3] || "schema.ts";
-const { errors, schemas } = await emitToFile(
-  session,
-  outputPath,
-  outputFilename,
-);
+const { errors, schemas } = await emitToFile(outputPath, outputFilename);
 
 console.info(`${schemas.length} schema(s) found`);
 

source/session.ts

@@ -0,0 +1,27 @@
+import { Session } from "@ftrack/api";
+import type {
+  ObjectType,
+  Type,
+  Priority,
+  ProjectSchema,
+  Status,
+} from "./emit.ts";
+import type { CustomAttributeConfiguration } from "./emitCustomAttributes.ts";
+
+export interface Schema {
+  ObjectType: ObjectType;
+  CustomAttributeConfiguration: CustomAttributeConfiguration;
+  Type: Type;
+  Priority: Priority;
+  ProjectSchema: ProjectSchema;
+  Status: Status;
+}
+
+export const session = new Session<Schema>(
+  process.env.FTRACK_SERVER ?? "",
+  process.env.FTRACK_API_USER ?? "",
+  process.env.FTRACK_API_KEY ?? "",
+  {
+    autoConnectEventHub: false,
+  },
+);

tsconfig.json

@@ -5,8 +5,7 @@
     "forceConsistentCasingInFileNames": true,
     "incremental": true,
     "isolatedModules": true,
-    "module": "ESNext",
-    "moduleResolution": "Node",
+    "module": "NodeNext",
     "lib": ["DOM", "DOM.Iterable", "ESNext"],
     "noEmit": true,
     "resolveJsonModule": true,
@@ -15,7 +14,8 @@
     "target": "ESNext",
     "useDefineForClassFields": true,
     "verbatimModuleSyntax": true,
-    "erasableSyntaxOnly": true
+    "erasableSyntaxOnly": true,
+    "allowImportingTsExtensions": true
   },
   "include": ["source/**/*.ts"]
 }