upcoming: [UIE-9780] - Add new API endpoints, types and queries for R… (#13187)

* upcoming: [UIE-9780] - Add new API endpoints, types and queries for Resource Locking feature(RESPROT2)

* Added changeset: Add new API endpoints and types for Resource Locking feature(RESPROT2)

* Added changeset: Add new API queries for CRUD of locks for Resource Locking feature(RESPROT2)

* Address review comments.

Author: tanushree-akamai

packages/api-v4/.changeset/pr-13187-upcoming-features-1765970845449.md

@@ -0,0 +1,5 @@
+---
+"@linode/api-v4": Upcoming Features
+---
+
+Add new API endpoints and types for Resource Locking feature(RESPROT2) ([#13187](https://github.com/linode/manager/pull/13187))

packages/api-v4/src/index.ts

@@ -24,6 +24,8 @@ export * from './kubernetes';
 
 export * from './linodes';
 
+export * from './locks';
+
 export * from './longview';
 
 export * from './managed';

packages/api-v4/src/locks/index.ts

@@ -0,0 +1,3 @@
+export * from './locks';
+
+export * from './types';

packages/api-v4/src/locks/locks.ts

@@ -0,0 +1,63 @@
+import { BETA_API_ROOT } from '../constants';
+import Request, { setData, setMethod, setURL, setXFilter } from '../request';
+
+import type { Filter, ResourcePage as Page, Params } from '../types';
+import type { CreateLockPayload, ResourceLock } from './types';
+
+/**
+ * getLocks
+ *
+ * Returns a paginated list of resource locks on your Account.
+ *
+ * @param params { Params } Pagination parameters
+ * @param filters { Filter } X-Filter for API
+ */
+export const getLocks = (params?: Params, filters?: Filter) =>
+  Request<Page<ResourceLock>>(
+    setURL(`${BETA_API_ROOT}/locks`),
+    setMethod('GET'),
+    setXFilter(filters),
+  );
+
+/**
+ * getLock
+ *
+ * Returns information about a single resource lock.
+ *
+ * @param lockId { number } The ID of the lock to retrieve.
+ */
+export const getLock = (lockId: number) =>
+  Request<ResourceLock>(
+    setURL(`${BETA_API_ROOT}/locks/${encodeURIComponent(lockId)}`),
+    setMethod('GET'),
+  );
+
+/**
+ * createLock
+ *
+ * Creates a new resource lock to prevent accidental deletion or modification.
+ *
+ * @param payload { CreateLockPayload } The lock creation payload
+ * @param payload.entity_type { string } The type of entity to lock (e.g., 'linode')
+ * @param payload.entity_id { number | string } The ID of the entity to lock
+ * @param payload.lock_type { string } The type of lock ('cannot_delete', 'cannot_delete_with_subresources')
+ */
+export const createLock = (payload: CreateLockPayload) =>
+  Request<ResourceLock>(
+    setURL(`${BETA_API_ROOT}/locks`),
+    setData(payload),
+    setMethod('POST'),
+  );
+
+/**
+ * deleteLock
+ *
+ * Deletes a resource lock, allowing the resource to be deleted or modified.
+ *
+ * @param lockId { number } The ID of the lock to delete.
+ */
+export const deleteLock = (lockId: number) =>
+  Request<{}>(
+    setURL(`${BETA_API_ROOT}/locks/${encodeURIComponent(lockId)}`),
+    setMethod('DELETE'),
+  );

packages/api-v4/src/locks/types.ts

@@ -0,0 +1,42 @@
+import type { EntityType } from '../entities';
+
+/**
+ * Types of locks that can be applied to a resource
+ */
+export type LockType = 'cannot_delete' | 'cannot_delete_with_subresources';
+
+/**
+ * Entity information attached to a lock
+ */
+export interface LockEntity {
+  id: number | string;
+  label?: string;
+  type: EntityType;
+  url?: string;
+}
+
+/**
+ * Request payload for creating a lock
+ * POST /v4beta/locks
+ */
+export interface CreateLockPayload {
+  /** Required: ID of the entity being locked */
+  entity_id: number | string;
+  /** Required: Type of the entity being locked */
+  entity_type: EntityType;
+  /** Required: Type of lock to apply */
+  lock_type: LockType;
+}
+
+/**
+ * Resource Lock object returned from API
+ * Response from POST /v4beta/locks
+ */
+export interface ResourceLock {
+  /** Information about the locked entity */
+  entity: LockEntity;
+  /** Unique identifier for the lock */
+  id: number;
+  /** Type of lock applied */
+  lock_type: LockType;
+}

packages/queries/.changeset/pr-13187-upcoming-features-1765970953049.md

@@ -0,0 +1,5 @@
+---
+"@linode/queries": Upcoming Features
+---
+
+Add new API queries for CRUD of locks for Resource Locking feature(RESPROT2)  ([#13187](https://github.com/linode/manager/pull/13187))

packages/queries/src/index.ts

@@ -10,6 +10,7 @@ export * from './firewalls';
 export * from './iam';
 export * from './images';
 export * from './linodes';
+export * from './locks';
 export * from './netloadbalancers';
 export * from './networking';
 export * from './networktransfer';

packages/queries/src/locks/index.ts

@@ -0,0 +1 @@
+export * from './locks';

packages/queries/src/locks/locks.ts

@@ -0,0 +1,109 @@
+import {
+  createLock,
+  deleteLock,
+  getLock,
+  getLocks,
+} from '@linode/api-v4/lib/locks';
+import { createQueryKeys } from '@lukemorales/query-key-factory';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import type { APIError, Filter, Params, ResourcePage } from '@linode/api-v4';
+import type {
+  CreateLockPayload,
+  ResourceLock,
+} from '@linode/api-v4/lib/locks/types';
+
+export const lockQueries = createQueryKeys('locks', {
+  lock: (id: number) => ({
+    queryFn: () => getLock(id),
+    queryKey: [id],
+  }),
+  locks: {
+    contextQueries: {
+      paginated: (params: Params = {}, filter: Filter = {}) => ({
+        queryFn: () => getLocks(params, filter),
+        queryKey: [params, filter],
+      }),
+    },
+    queryKey: null,
+  },
+});
+
+/**
+ * useLocksQuery
+ *
+ * Returns a paginated list of resource locks
+ *
+ * @example
+ * const { data, isLoading } = useLocksQuery();
+ */
+export const useLocksQuery = (params: Params = {}, filter: Filter = {}) => {
+  return useQuery<ResourcePage<ResourceLock>, APIError[]>({
+    ...lockQueries.locks._ctx.paginated(params, filter),
+  });
+};
+
+/**
+ * useLockQuery
+ *
+ * Returns a single resource lock by ID
+ *
+ * @example
+ * const { data: lock } = useLockQuery(123);
+ */
+export const useLockQuery = (id: number, enabled: boolean = true) => {
+  return useQuery<ResourceLock, APIError[]>({
+    ...lockQueries.lock(id),
+    enabled,
+  });
+};
+
+/**
+ *
+ * Creates a new resource lock
+ * POST /v4beta/locks
+ *
+ * @example
+ * const { mutate: createLock } = useCreateLockMutation();
+ * createLock({
+ *   entity_type: 'linode',
+ *   entity_id: 12345,
+ *   lock_type: 'cannot_delete',
+ * });
+ */
+export const useCreateLockMutation = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<ResourceLock, APIError[], CreateLockPayload>({
+    mutationFn: (payload) => createLock(payload),
+    onSuccess: () => {
+      // Invalidate all lock queries
+      queryClient.invalidateQueries({
+        queryKey: lockQueries.locks.queryKey,
+      });
+    },
+  });
+};
+
+/**
+ *
+ * Deletes a resource lock
+ * DELETE /v4beta/locks/{lock_id}
+ *
+ * @example
+ * const { mutate: deleteLock } = useDeleteLockMutation();
+ * deleteLock(123);
+ */
+export const useDeleteLockMutation = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<{}, APIError[], number>({
+    mutationFn: (lockId) => deleteLock(lockId),
+    onSuccess: () => {
+      // Invalidate all lock queries
+      queryClient.invalidateQueries({
+        queryKey: lockQueries.locks.queryKey,
+      });
+    },
+  });
+};