feat: add function support

.circleci/config.yml

@@ -62,6 +62,7 @@ jobs:
     steps:
       - with-workspace
       - run: npm run build
+      - persist-workspace
 
   lint:
     executor: docker-with-node
@@ -81,6 +82,12 @@ jobs:
       - store_artifacts:
           path: ./reports/unit-results.xml
 
+  size:
+    executor: docker-with-node
+    steps:
+      - with-workspace
+      - run: npm run test:size
+
   integration:
     executor: docker-with-node
     steps:
@@ -122,6 +129,10 @@ workflows:
             - build
             - unit
             - lint
+      - size:
+          requires:
+            - prepare
+            - build
 
       - release:
           context: vault

lib/adapters/REST/endpoints/function.ts

@@ -0,0 +1,41 @@
+import type { AxiosInstance } from 'contentful-sdk-core'
+import * as raw from './raw'
+import { normalizeSelect } from './utils'
+import type {
+  CollectionProp,
+  GetFunctionForEnvParams,
+  GetFunctionParams,
+} from '../../../common-types'
+import type { RestEndpoint } from '../types'
+import type { FunctionProps } from '../../../entities/function'
+
+const getBaseUrl = (params: GetFunctionParams) =>
+  `/organizations/${params.organizationId}/app_definitions/${params.appDefinitionId}/functions`
+
+const getFunctionUrl = (params: GetFunctionParams) =>
+  `${getBaseUrl(params)}/${params.functionId}`
+
+const getFunctionsEnvURL = (params: GetFunctionForEnvParams) => {
+    return `/spaces/${params.spaceId}/environments/${params.environmentId}/app_installations/${params.appInstallationId}/functions`
+}
+
+export const get: RestEndpoint<'Function', 'get'> = (
+  http: AxiosInstance,
+  params: GetFunctionParams
+) => {
+  return raw.get<FunctionProps>(http, getFunctionUrl(params))
+}
+
+export const getMany: RestEndpoint<'Function', 'getMany'> = (
+  http: AxiosInstance,
+  params: GetFunctionParams
+) => {
+  return raw.get<CollectionProp<FunctionProps>>(http, getBaseUrl(params))
+}
+
+export const getManyForEnvironment: RestEndpoint<'Function', 'getManyForEnvironment'> = (
+  http: AxiosInstance,
+  params: GetFunctionForEnvParams
+) => {
+  return raw.get<CollectionProp<FunctionProps>>(http, getFunctionsEnvURL(params))
+}

lib/common-types.ts

@@ -533,6 +533,10 @@ type MRInternal<UA extends boolean> = {
   (opts: MROpts<'Extension', 'update', UA>): MRReturn<'Extension', 'update'>
   (opts: MROpts<'Extension', 'delete', UA>): MRReturn<'Extension', 'delete'>
 
+  (opts: MROpts<'Function', 'get', UA>): MRReturn<'Function', 'get'>
+  (opts: MROpts<'Function', 'getMany', UA>): MRReturn<'Function', 'getMany'>
+  (opts: MROpts<'Function', 'getManyForEnvironment', UA>): MRReturn<'Function', 'getManyForEnvironment'> 
+
   (opts: MROpts<'Locale', 'get', UA>): MRReturn<'Locale', 'get'>
   (opts: MROpts<'Locale', 'getMany', UA>): MRReturn<'Locale', 'getMany'>
   (opts: MROpts<'Locale', 'delete', UA>): MRReturn<'Locale', 'delete'>
@@ -1276,12 +1280,6 @@ export type MRActions = {
       return: EditorInterfaceProps
     }
   }
-  Function: {
-    getMany: {
-      params: GetAppDefinitionParams & QueryParams
-      return: CollectionProp<FunctionProps>
-    }
-  }
   Environment: {
     get: { params: GetSpaceEnvironmentParams; return: EnvironmentProps }
     getMany: {
@@ -1494,6 +1492,11 @@ export type MRActions = {
     }
     delete: { params: GetExtensionParams; return: any }
   }
+  Function: {
+    get: { params: GetFunctionParams; return: FunctionProps }
+    getMany: { params: GetFunctionParams; return: CollectionProp<FunctionProps> }
+    getManyForEnvironment: { params: GetFunctionForEnvParams; return: CollectionProp<FunctionProps> }
+  }
   Locale: {
     get: { params: GetSpaceEnvironmentParams & { localeId: string }; return: LocaleProps }
     getMany: {
@@ -2076,6 +2079,8 @@ export type GetEditorInterfaceParams = GetSpaceEnvironmentParams & { contentType
 export type GetEntryParams = GetSpaceEnvironmentParams & { entryId: string }
 export type GetExtensionParams = GetSpaceEnvironmentParams & { extensionId: string }
 export type GetEnvironmentTemplateParams = GetOrganizationParams & { environmentTemplateId: string }
+export type GetFunctionParams = GetAppDefinitionParams & { functionId?: string}
+export type GetFunctionForEnvParams = GetSpaceParams & { environmentId: string } & { appInstallationId: string }
 export type GetOrganizationParams = { organizationId: string }
 export type GetReleaseParams = GetSpaceEnvironmentParams & { releaseId: string }
 export type GetSnapshotForContentTypeParams = GetSpaceEnvironmentParams & { contentTypeId: string }

lib/plain/common-types.ts

@@ -5,7 +5,6 @@ import type {
   CollectionProp,
   CursorPaginatedCollectionProp,
   EnvironmentTemplateParams,
-  GetAppDefinitionParams,
   GetBulkActionParams,
   GetContentTypeParams,
   GetEnvironmentTemplateParams,
@@ -87,19 +86,19 @@ import type { AppInstallationPlainClientAPI } from './entities/app-installation'
 import type { WebhookPlainClientAPI } from './entities/webhook'
 import type { AppSignedRequestPlainClientAPI } from './entities/app-signed-request'
 import type { AppSigningSecretPlainClientAPI } from './entities/app-signing-secret'
-import type { ExtensionPlainClientAPI } from './entities/extension'
 import type { AppEventSubscriptionPlainClientAPI } from './entities/app-event-subscription'
 import type { AppKeyPlainClientAPI } from './entities/app-key'
 import type { UserPlainClientAPI } from './entities/user'
 import type { UploadPlainClientAPI } from './entities/upload'
-import type { OrganizationPlainClientAPI } from './entities/organization'
+import type { EnvironmentPlainClientAPI } from './entities/environment'
+import type { EnvironmentAliasPlainClientAPI } from './entities/environment-alias'
+import type { ExtensionPlainClientAPI } from './entities/extension'
+import type { FunctionPlainClientAPI } from './entities/function'
 import type { LocalePlainClientAPI } from './entities/locale'
+import type { OrganizationPlainClientAPI } from './entities/organization'
 import type { SpacePlainClientAPI } from './entities/space'
-import type { SpaceMembershipPlainClientAPI } from './entities/space-membership'
 import type { SpaceMemberPlainClientAPI } from './entities/space-member'
-import type { EnvironmentPlainClientAPI } from './entities/environment'
-import type { EnvironmentAliasPlainClientAPI } from './entities/environment-alias'
-import type { CommentPlainClientAPI } from './entities/comment'
+import type { SpaceMembershipPlainClientAPI } from './entities/space-membership'
 import type { TaskPlainClientAPI } from './entities/task'
 import type { WorkflowPlainClientAPI } from './entities/workflow'
 import type { WorkflowsChangelogPlainClientAPI } from './entities/workflows-changelog'
@@ -136,11 +135,7 @@ export type PlainClientAPI = {
   appSignedRequest: AppSignedRequestPlainClientAPI
   appSigningSecret: AppSigningSecretPlainClientAPI
   appAccessToken: AppAccessTokenPlainClientAPI
-  function: {
-    getMany(
-      params: OptionalDefaults<GetAppDefinitionParams & QueryParams>
-    ): Promise<CollectionProp<FunctionProps>>
-  }
+  function: FunctionPlainClientAPI
   editorInterface: EditorInterfacePlainClientAPI
   space: SpacePlainClientAPI
   environment: EnvironmentPlainClientAPI

lib/plain/entities/function.ts

@@ -0,0 +1,61 @@
+import type {
+  CollectionProp,
+  GetFunctionParams,
+  GetFunctionForEnvParams,
+  QueryParams,
+} from '../../common-types'
+import type { FunctionProps } from '../../entities/function'
+import type { OptionalDefaults } from '../wrappers/wrap'
+
+export type FunctionPlainClientAPI = {
+  /**
+   * Fetches the specified function
+   * @param params organization ID, app definition ID, entity ID to identify the function
+   * @returns the function
+   * @throws if the request fails, or the Function is not found
+   * @example
+   * ```javascript
+   * const func = await client.function.get({
+   *   organizationId: "<org_id>",
+   *   appDefinitionId: "<app_definition_id>",
+   *   functionId: "<function_id>",
+   * });
+   * ```
+   */
+  get(params: OptionalDefaults<GetFunctionParams>): Promise<FunctionProps>
+
+  /**
+   * Fetches all functions for the given app
+   * @param params organization ID, app definition ID to identify the functions
+   * @returns an object containing an array of Functions
+   * @throws if the request fails, or the App is not found
+   * @example
+   * ```javascript
+   * const functions = await client.function.getMany({
+   *   organizationId: "<org_id>",
+   *   appDefinitionId: "<app_definition_id>",
+   * });
+   * ```
+   */
+  getMany(
+    params: OptionalDefaults<GetFunctionParams & QueryParams>
+  ): Promise<CollectionProp<FunctionProps>>
+
+  /**
+   * Fetches all functions for the given environment
+   * @param params space ID, environment ID, app installation ID to identify the functions
+   * @returns an object containing an array of Functions
+   * @throws if the request fails, or the Environment is not found
+   * @example
+   * ```javascript
+   * const functions = await client.function.getManyForEnvironment({
+   *   spaceId: "<space_id>",
+   *   environmentId: "<environment_id>",
+   *   appInstallationId: "<app_installation_id>",
+   * });
+   * ```
+   */
+  getManyForEnvironment(
+    params: OptionalDefaults<GetFunctionForEnvParams & QueryParams>
+  ): Promise<CollectionProp<FunctionProps>>
+}

lib/plain/plain-client.ts

@@ -123,7 +123,9 @@ export const createPlainClient = (
       update: wrap(wrapParams, 'ConceptScheme', 'update'),
     },
     function: {
+      get: wrap(wrapParams, 'Function', 'get'),
       getMany: wrap(wrapParams, 'Function', 'getMany'),
+      getManyForEnvironment: wrap(wrapParams, 'Function', 'getManyForEnvironment')
     },
     editorInterface: {
       get: wrap(wrapParams, 'EditorInterface', 'get'),