@trackunit/serverside-utils 0.5.5 → 0.5.6

package/index.cjs.js

@@ -58,6 +58,10 @@ const getErrorBody = async (response) => {
  * The operation name is appended to the URL so each call stays attributable by
  * its unique operation name when observed in GraphQL Hive.
  *
+ * @deprecated Use `createTrackunitGraphqlClient` instead. It reads authentication from the Hono
+ * context, resolves the endpoint through {@link getGraphqlUrl}, and infers result and variable
+ * types from a generated `TypedDocumentNode`, so a hand-written query string and response schema
+ * are no longer needed.
  * @template TData The shape of the validated `data` payload.
  * @param props - The properties of the query execution.
  * @param props.baseUrl - The base GraphQL URL, e.g. from {@link getGraphqlUrl}.
@@ -361,40 +365,71 @@ const getDatabricksAccessToken = async ({ context, databricksHost, databricksCli
     };
 };
 
-/**
- * Operation names are intentionally verbose and unique so the calls are easy to
- * trace back to this utility (e.g. when inspecting GraphQL Hive). The
- * `ServersideUtils` prefix already attributes every call to this utility.
- */
-const USER_PERMISSIONS_OPERATION_NAME = "ServersideUtilsHasScopesUserPermissions";
-const USER_PERMISSIONS_QUERY = `query ${USER_PERMISSIONS_OPERATION_NAME}($securableIds: [ID!]!) {
-  userCurrent {
-    user {
-      permissions(securableIds: $securableIds) {
-        securableId
-        permissions
-      }
-    }
-  }
-}`;
-const UserPermissionsDataSchema = zod.z.object({
-    userCurrent: zod.z
-        .object({
-        user: zod.z
-            .object({
-            permissions: zod.z
-                .array(zod.z
-                .object({
-                securableId: zod.z.string(),
-                permissions: zod.z.array(zod.z.string().nullable()).nullable(),
-            })
-                .nullable())
-                .nullable(),
-        })
-            .nullable(),
-    })
-        .nullable(),
-});
+const ServersideUtilsHasScopesUserPermissionsDocument = {
+    kind: "Document",
+    definitions: [
+        {
+            kind: "OperationDefinition",
+            operation: "query",
+            name: { kind: "Name", value: "ServersideUtilsHasScopesUserPermissions" },
+            variableDefinitions: [
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "securableIds" } },
+                    type: {
+                        kind: "NonNullType",
+                        type: {
+                            kind: "ListType",
+                            type: { kind: "NonNullType", type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } },
+                        },
+                    },
+                },
+            ],
+            selectionSet: {
+                kind: "SelectionSet",
+                selections: [
+                    {
+                        kind: "Field",
+                        name: { kind: "Name", value: "userCurrent" },
+                        selectionSet: {
+                            kind: "SelectionSet",
+                            selections: [
+                                {
+                                    kind: "Field",
+                                    name: { kind: "Name", value: "user" },
+                                    selectionSet: {
+                                        kind: "SelectionSet",
+                                        selections: [
+                                            {
+                                                kind: "Field",
+                                                name: { kind: "Name", value: "permissions" },
+                                                arguments: [
+                                                    {
+                                                        kind: "Argument",
+                                                        name: { kind: "Name", value: "securableIds" },
+                                                        value: { kind: "Variable", name: { kind: "Name", value: "securableIds" } },
+                                                    },
+                                                ],
+                                                selectionSet: {
+                                                    kind: "SelectionSet",
+                                                    selections: [
+                                                        { kind: "Field", name: { kind: "Name", value: "securableId" } },
+                                                        { kind: "Field", name: { kind: "Name", value: "permissions" } },
+                                                    ],
+                                                },
+                                            },
+                                        ],
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        },
+    ],
+};
+
 /**
  * The only scope prefix currently supported. Scopes are configured by the
  * developer in the Iris app manifest and follow the `<securable>.<...>` shape
@@ -403,14 +438,10 @@ const UserPermissionsDataSchema = zod.z.object({
  */
 const SUPPORTED_SCOPE_PREFIX = "account";
 const getScopePrefix = (scope) => scope.split(".")[0] ?? "";
-const getCurrentUserAccountPermissions = async ({ baseUrl, userToken, accountId, }) => {
-    const data = await executePublicQuery({
-        baseUrl,
-        userToken,
-        operationName: USER_PERMISSIONS_OPERATION_NAME,
-        query: USER_PERMISSIONS_QUERY,
+const getCurrentUserAccountPermissions = async ({ context, accountId, }) => {
+    const data = await createTrackunitGraphqlClient({ context }).request({
+        document: ServersideUtilsHasScopesUserPermissionsDocument,
         variables: { securableIds: [accountId] },
-        dataSchema: UserPermissionsDataSchema,
     });
     return (data.userCurrent?.user?.permissions ?? [])
         .flatMap(securablePermission => securablePermission?.permissions ?? [])
@@ -455,8 +486,7 @@ const hasScopes = async ({ context, scopes }) => {
         throw new Error(`Unsupported scope "${unsupportedScope}": only "${SUPPORTED_SCOPE_PREFIX}" scopes are currently supported`);
     }
     const { accountId } = getAccountId({ context });
-    const baseUrl = getGraphqlUrl();
-    const grantedScopes = await getCurrentUserAccountPermissions({ baseUrl, userToken, accountId });
+    const grantedScopes = await getCurrentUserAccountPermissions({ context, accountId });
     return scopes.every(scope => grantedScopes.includes(scope));
 };
 

package/index.esm.js

@@ -56,6 +56,10 @@ const getErrorBody = async (response) => {
  * The operation name is appended to the URL so each call stays attributable by
  * its unique operation name when observed in GraphQL Hive.
  *
+ * @deprecated Use `createTrackunitGraphqlClient` instead. It reads authentication from the Hono
+ * context, resolves the endpoint through {@link getGraphqlUrl}, and infers result and variable
+ * types from a generated `TypedDocumentNode`, so a hand-written query string and response schema
+ * are no longer needed.
  * @template TData The shape of the validated `data` payload.
  * @param props - The properties of the query execution.
  * @param props.baseUrl - The base GraphQL URL, e.g. from {@link getGraphqlUrl}.
@@ -359,40 +363,71 @@ const getDatabricksAccessToken = async ({ context, databricksHost, databricksCli
     };
 };
 
-/**
- * Operation names are intentionally verbose and unique so the calls are easy to
- * trace back to this utility (e.g. when inspecting GraphQL Hive). The
- * `ServersideUtils` prefix already attributes every call to this utility.
- */
-const USER_PERMISSIONS_OPERATION_NAME = "ServersideUtilsHasScopesUserPermissions";
-const USER_PERMISSIONS_QUERY = `query ${USER_PERMISSIONS_OPERATION_NAME}($securableIds: [ID!]!) {
-  userCurrent {
-    user {
-      permissions(securableIds: $securableIds) {
-        securableId
-        permissions
-      }
-    }
-  }
-}`;
-const UserPermissionsDataSchema = z.object({
-    userCurrent: z
-        .object({
-        user: z
-            .object({
-            permissions: z
-                .array(z
-                .object({
-                securableId: z.string(),
-                permissions: z.array(z.string().nullable()).nullable(),
-            })
-                .nullable())
-                .nullable(),
-        })
-            .nullable(),
-    })
-        .nullable(),
-});
+const ServersideUtilsHasScopesUserPermissionsDocument = {
+    kind: "Document",
+    definitions: [
+        {
+            kind: "OperationDefinition",
+            operation: "query",
+            name: { kind: "Name", value: "ServersideUtilsHasScopesUserPermissions" },
+            variableDefinitions: [
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "securableIds" } },
+                    type: {
+                        kind: "NonNullType",
+                        type: {
+                            kind: "ListType",
+                            type: { kind: "NonNullType", type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } },
+                        },
+                    },
+                },
+            ],
+            selectionSet: {
+                kind: "SelectionSet",
+                selections: [
+                    {
+                        kind: "Field",
+                        name: { kind: "Name", value: "userCurrent" },
+                        selectionSet: {
+                            kind: "SelectionSet",
+                            selections: [
+                                {
+                                    kind: "Field",
+                                    name: { kind: "Name", value: "user" },
+                                    selectionSet: {
+                                        kind: "SelectionSet",
+                                        selections: [
+                                            {
+                                                kind: "Field",
+                                                name: { kind: "Name", value: "permissions" },
+                                                arguments: [
+                                                    {
+                                                        kind: "Argument",
+                                                        name: { kind: "Name", value: "securableIds" },
+                                                        value: { kind: "Variable", name: { kind: "Name", value: "securableIds" } },
+                                                    },
+                                                ],
+                                                selectionSet: {
+                                                    kind: "SelectionSet",
+                                                    selections: [
+                                                        { kind: "Field", name: { kind: "Name", value: "securableId" } },
+                                                        { kind: "Field", name: { kind: "Name", value: "permissions" } },
+                                                    ],
+                                                },
+                                            },
+                                        ],
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        },
+    ],
+};
+
 /**
  * The only scope prefix currently supported. Scopes are configured by the
  * developer in the Iris app manifest and follow the `<securable>.<...>` shape
@@ -401,14 +436,10 @@ const UserPermissionsDataSchema = z.object({
  */
 const SUPPORTED_SCOPE_PREFIX = "account";
 const getScopePrefix = (scope) => scope.split(".")[0] ?? "";
-const getCurrentUserAccountPermissions = async ({ baseUrl, userToken, accountId, }) => {
-    const data = await executePublicQuery({
-        baseUrl,
-        userToken,
-        operationName: USER_PERMISSIONS_OPERATION_NAME,
-        query: USER_PERMISSIONS_QUERY,
+const getCurrentUserAccountPermissions = async ({ context, accountId, }) => {
+    const data = await createTrackunitGraphqlClient({ context }).request({
+        document: ServersideUtilsHasScopesUserPermissionsDocument,
         variables: { securableIds: [accountId] },
-        dataSchema: UserPermissionsDataSchema,
     });
     return (data.userCurrent?.user?.permissions ?? [])
         .flatMap(securablePermission => securablePermission?.permissions ?? [])
@@ -453,8 +484,7 @@ const hasScopes = async ({ context, scopes }) => {
         throw new Error(`Unsupported scope "${unsupportedScope}": only "${SUPPORTED_SCOPE_PREFIX}" scopes are currently supported`);
     }
     const { accountId } = getAccountId({ context });
-    const baseUrl = getGraphqlUrl();
-    const grantedScopes = await getCurrentUserAccountPermissions({ baseUrl, userToken, accountId });
+    const grantedScopes = await getCurrentUserAccountPermissions({ context, accountId });
     return scopes.every(scope => grantedScopes.includes(scope));
 };
 

package/migrations/entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.js","sourceRoot":"","sources":["../../../../../libs/iris-app-sdk/serverside-utils/migrations/entry.ts"],"names":[],"mappings":"","sourcesContent":["export {};\n"]}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@trackunit/serverside-utils",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "engines": {
     "node": ">=24.x"
   },
   "dependencies": {
+    "@graphql-typed-document-node/core": "^3.2.0",
     "@trackunit/server-graphql-client": "0.0.6",
     "jwt-decode": "^3.1.2",
     "zod": "^3.25.76"

package/src/execute-public-query.d.ts

@@ -33,6 +33,10 @@ export type ExecutePublicQueryProps<TData> = {
  * The operation name is appended to the URL so each call stays attributable by
  * its unique operation name when observed in GraphQL Hive.
  *
+ * @deprecated Use `createTrackunitGraphqlClient` instead. It reads authentication from the Hono
+ * context, resolves the endpoint through {@link getGraphqlUrl}, and infers result and variable
+ * types from a generated `TypedDocumentNode`, so a hand-written query string and response schema
+ * are no longer needed.
  * @template TData The shape of the validated `data` payload.
  * @param props - The properties of the query execution.
  * @param props.baseUrl - The base GraphQL URL, e.g. from {@link getGraphqlUrl}.

package/src/generated/graphql-api/fragment-masking.d.ts

@@ -0,0 +1,19 @@
+import { ResultOf, DocumentTypeDecoration, TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { Incremental } from './graphql';
+export type FragmentType<TDocumentType extends DocumentTypeDecoration<any, any>> = TDocumentType extends DocumentTypeDecoration<infer TType, any> ? [TType] extends [{
+    ' $fragmentName'?: infer TKey;
+}] ? TKey extends string ? {
+    ' $fragmentRefs'?: {
+        [key in TKey]: TType;
+    };
+} : never : never : never;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>>): TType;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | undefined): TType | undefined;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null): TType | null;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null | undefined): TType | null | undefined;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>>): Array<TType>;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined): Array<TType> | null | undefined;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>>): ReadonlyArray<TType>;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined): ReadonlyArray<TType> | null | undefined;
+export declare function makeFragmentData<F extends DocumentTypeDecoration<any, any>, FT extends ResultOf<F>>(data: FT, _fragment: F): FragmentType<F>;
+export declare function isFragmentReady<TQuery, TFrag>(queryNode: DocumentTypeDecoration<TQuery, any>, fragmentNode: TypedDocumentNode<TFrag>, data: FragmentType<TypedDocumentNode<Incremental<TFrag>, any>> | null | undefined): data is FragmentType<typeof fragmentNode>;

package/src/generated/graphql-api/gql.d.ts

@@ -0,0 +1,37 @@
+import * as types from './graphql';
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+/**
+ * Map of all GraphQL operations in the project.
+ *
+ * This map has several performance disadvantages:
+ * 1. It is not tree-shakeable, so it will include all operations in the project.
+ * 2. It is not minifiable, so the string of a GraphQL query will be multiple times inside the bundle.
+ * 3. It does not support dead code elimination, so it will add unused operations.
+ *
+ * Therefore it is highly recommended to use the babel or swc plugin for production.
+ * Learn more about it here: https://the-guild.dev/graphql/codegen/plugins/presets/preset-client#reducing-bundle-size
+ */
+declare const documents: {
+    "query ServersideUtilsHasScopesUserPermissions($securableIds: [ID!]!) {\n  userCurrent {\n    user {\n      permissions(securableIds: $securableIds) {\n        securableId\n        permissions\n      }\n    }\n  }\n}": DocumentNode<types.ServersideUtilsHasScopesUserPermissionsQuery, types.Exact<{
+        securableIds: Array<types.Scalars["ID"]["input"]> | types.Scalars["ID"]["input"];
+    }>>;
+};
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ *
+ *
+ * @example
+ * ```ts
+ * const query = graphql(`query GetUser($id: ID!) { user(id: $id) { name } }`);
+ * ```
+ *
+ * The query argument is unknown!
+ * Please regenerate the types.
+ */
+export declare function graphql(source: string): unknown;
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function graphql(source: "query ServersideUtilsHasScopesUserPermissions($securableIds: [ID!]!) {\n  userCurrent {\n    user {\n      permissions(securableIds: $securableIds) {\n        securableId\n        permissions\n      }\n    }\n  }\n}"): (typeof documents)["query ServersideUtilsHasScopesUserPermissions($securableIds: [ID!]!) {\n  userCurrent {\n    user {\n      permissions(securableIds: $securableIds) {\n        securableId\n        permissions\n      }\n    }\n  }\n}"];
+export type DocumentType<TDocumentNode extends DocumentNode<any, any>> = TDocumentNode extends DocumentNode<infer TType, any> ? TType : never;
+export {};

package/src/generated/graphql-api/graphql.d.ts

@@ -0,0 +1,132 @@
+import { TypedDocumentNode as DocumentNode } from "@graphql-typed-document-node/core";
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T> | undefined;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
+};
+export type DateTimeISOString = string;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    /** The ISO 4217 currency code of the monetary field definition. */
+    Currency: {
+        input: string;
+        output: string;
+    };
+    /**
+     * Cursor scalar type used for pagination
+     * Represents an opaque cursor string
+     */
+    Cursor: {
+        input: string;
+        output: string;
+    };
+    /** Date scalar */
+    Date: {
+        input: DateTimeISOString;
+        output: DateTimeISOString;
+    };
+    /** DateTime scalar */
+    DateTime: {
+        input: DateTimeISOString;
+        output: DateTimeISOString;
+    };
+    /** Duration represents an ISO 8601 duration */
+    Duration: {
+        input: any;
+        output: any;
+    };
+    /** Valid email address according to https://owasp.org/www-community/OWASP_Validation_Regex_Repository */
+    EmailAddress: {
+        input: string;
+        output: string;
+    };
+    /** A (possiblely multidimensional) set of coordinates following x, y, z order. */
+    GeoJSONCoordinates: {
+        input: [number, number] | [number, number][] | [number, number][][];
+        output: [number, number] | [number, number][] | [number, number][][];
+    };
+    /** The `JSON` scalar type represents JSON values */
+    JSON: {
+        input: any;
+        output: any;
+    };
+    /** 24-hour clock time string in the format hh:mm:ss.sss or hh:mm:ss if partial seconds is zero */
+    LocalTime: {
+        input: any;
+        output: any;
+    };
+    /** Javascript `Long`. Type represents a 64 bit integer. */
+    Long: {
+        input: any;
+        output: any;
+    };
+    /** Phone number in E.164 format */
+    PhoneNumber: {
+        input: string;
+        output: string;
+    };
+    /** Uniform resource locator */
+    Url: {
+        input: string;
+        output: string;
+    };
+    /** YearMonth scalar */
+    YearMonth: {
+        input: any;
+        output: any;
+    };
+};
+export type ServersideUtilsHasScopesUserPermissionsQueryVariables = Exact<{
+    securableIds: Array<Scalars["ID"]["input"]> | Scalars["ID"]["input"];
+}>;
+export type ServersideUtilsHasScopesUserPermissionsQuery = {
+    __typename?: "Query";
+    userCurrent: {
+        __typename?: "CurrentUser";
+        user: {
+            __typename?: "User";
+            permissions: Array<{
+                __typename?: "SecurablePermission";
+                securableId: string;
+                permissions: Array<string | null>;
+            } | null> | null;
+        } | null;
+    } | null;
+};
+export declare const ServersideUtilsHasScopesUserPermissionsDocument: DocumentNode<ServersideUtilsHasScopesUserPermissionsQuery, ServersideUtilsHasScopesUserPermissionsQueryVariables>;

package/src/generated/graphql-api/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./fragment-masking";
+export * from "./gql";