contentful-management 11.60.3 → 12.0.0-beta.10

package/dist/types/entities/function-log.js

@@ -0,0 +1,23 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+function wrapFunctionLog(makeRequest, data) {
+    const functionLog = toPlainObject(copy(data));
+    return freezeSys(functionLog);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-function data
+ * @return Wrapped App Function collection data
+ */
+const wrapFunctionLogCollection = wrapCollection(wrapFunctionLog);
+
+export { wrapFunctionLog, wrapFunctionLogCollection };

package/dist/types/entities/function.d.ts

@@ -0,0 +1,32 @@
+import type { Link, DefaultElements } from '../common-types.js';
+import type { MakeRequest } from '../common-types.js';
+export type FunctionProps = {
+    sys: {
+        id: string;
+        type: 'Function';
+        createdBy: Link<'User'>;
+        createdAt: string;
+        updatedBy: Link<'User'>;
+        updatedAt: string;
+        organization: Link<'Organization'>;
+        appDefinition: Link<'AppDefinition'>;
+    };
+    name: string;
+    description: string;
+    path: string;
+    accepts: string[];
+    allowNetworks?: string[];
+};
+export interface Function extends FunctionProps, DefaultElements<FunctionProps> {
+}
+/**
+ * @private
+ * @param makeRequest - (real) function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+export declare function wrapFunction(makeRequest: MakeRequest, data: FunctionProps): FunctionProps;
+/**
+ * @private
+ */
+export declare const wrapFunctionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<FunctionProps>) => import("../common-types.js").Collection<FunctionProps, FunctionProps>;

package/dist/types/entities/function.js

@@ -0,0 +1,63 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createFunctionApi(makeRequest) {
+    return {
+        getFunction: function getFunction() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Function',
+                action: 'get',
+                params: {
+                    organizationId: raw.sys.organization.sys.id,
+                    appDefinitionId: raw.sys.appDefinition.sys.id,
+                    functionId: raw.sys.id,
+                },
+            }).then((data) => wrapFunction(makeRequest, data));
+        },
+        getManyFunctions: function getManyFunctions() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Function',
+                action: 'getMany',
+                params: {
+                    appDefinitionId: raw.sys.appDefinition.sys.id,
+                    organizationId: raw.sys.organization.sys.id,
+                },
+            }).then((data) => wrapFunctionCollection(makeRequest, data));
+        },
+        getManyFunctionsForEnvironment(spaceId, environmentId, appInstallationId) {
+            return makeRequest({
+                entityType: 'Function',
+                action: 'getManyForEnvironment',
+                params: {
+                    spaceId: spaceId,
+                    environmentId: environmentId,
+                    appInstallationId: appInstallationId,
+                },
+            }).then((data) => wrapFunctionCollection(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - (real) function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+function wrapFunction(makeRequest, data) {
+    const func = toPlainObject(copy(data));
+    const funcWithMethods = enhanceWithMethods(func, createFunctionApi(makeRequest));
+    return freezeSys(funcWithMethods);
+}
+/**
+ * @private
+ */
+const wrapFunctionCollection = wrapCollection(wrapFunction);
+
+export { wrapFunction, wrapFunctionCollection };

package/dist/types/entities/locale.d.ts

@@ -0,0 +1,95 @@
+import type { Except, SetOptional } from 'type-fest';
+import type { BasicMetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types.js';
+export type LocaleProps = {
+    sys: BasicMetaSysProps & {
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+    };
+    /**
+     * Locale name
+     */
+    name: string;
+    /**
+     * Locale code (example: en-us)
+     */
+    code: string;
+    /**
+     * Internal locale code
+     */
+    internal_code: string;
+    /**
+     * Locale code to fallback to when there is not content for the current locale
+     */
+    fallbackCode: string | null;
+    /**
+     *  If the content under this locale should be available on the CDA (for public reading)
+     */
+    contentDeliveryApi: boolean;
+    /**
+     * If the content under this locale should be available on the CMA (for editing)
+     */
+    contentManagementApi: boolean;
+    /**
+     * If this is the default locale
+     */
+    default: boolean;
+    /**
+     * If the locale needs to be filled in on entries or not
+     */
+    optional: boolean;
+};
+export type CreateLocaleProps = Omit<SetOptional<Except<LocaleProps, 'sys'>, 'optional' | 'contentManagementApi' | 'default' | 'contentDeliveryApi'>, 'internal_code'>;
+export interface Locale extends LocaleProps, DefaultElements<LocaleProps> {
+    /**
+     * Deletes this object on the server.
+     * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getLocale('<locale_id>'))
+     * .then((locale) => locale.delete())
+     * .then(() => console.log(`locale deleted.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return Object returned from the server with updated changes.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getLocale('<locale_id>'))
+     * .then((locale) => {
+     *   locale.name = 'New locale name'
+     *   return locale.update()
+     * })
+     * .then((locale) => console.log(`locale ${locale.sys.id} updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<Locale>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw locale data
+ * @return Wrapped locale data
+ */
+export declare function wrapLocale(makeRequest: MakeRequest, data: LocaleProps): Locale;
+/**
+ * @private
+ */
+export declare const wrapLocaleCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<LocaleProps>) => import("../common-types.js").Collection<Locale, LocaleProps>;

package/dist/types/entities/locale.js

@@ -0,0 +1,54 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createLocaleApi(makeRequest) {
+    const getParams = (locale) => ({
+        spaceId: locale.sys.space.sys.id,
+        environmentId: locale.sys.environment.sys.id,
+        localeId: locale.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Locale',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapLocale(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Locale',
+                action: 'delete',
+                params: getParams(raw),
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw locale data
+ * @return Wrapped locale data
+ */
+function wrapLocale(makeRequest, data) {
+    delete data.internal_code;
+    const locale = toPlainObject(copy(data));
+    const localeWithMethods = enhanceWithMethods(locale, createLocaleApi(makeRequest));
+    return freezeSys(localeWithMethods);
+}
+/**
+ * @private
+ */
+const wrapLocaleCollection = wrapCollection(wrapLocale);
+
+export { wrapLocale, wrapLocaleCollection };

package/dist/types/entities/oauth-application.d.ts

@@ -0,0 +1,56 @@
+import type { BasicMetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
+type OAuthApplicationSysProps = BasicMetaSysProps & {
+    lastUsedAt: string | null;
+};
+export declare enum ScopeValues {
+    Read = "content_management_read",
+    Manage = "content_management_manage"
+}
+export type OAuthApplicationProps = {
+    name: string;
+    description: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    scopes: ScopeValues[];
+    confidential: boolean;
+    sys: OAuthApplicationSysProps;
+};
+export type CreateOAuthApplicationProps = {
+    name: string;
+    description: string;
+    redirectUri: string;
+    scopes: ScopeValues[];
+    confidential: boolean;
+};
+export type UpdateOAuthApplicationProps = {
+    name?: string;
+    description?: string;
+    redirectUri?: string;
+    scopes?: ScopeValues[];
+    confidential?: boolean;
+};
+export interface OAuthApplication extends OAuthApplicationProps, DefaultElements<OAuthApplicationProps> {
+    /**
+     * Deletes an OAuth application
+     * @return Promise for the deleted OAuth application
+     */
+    delete(): Promise<void>;
+    /**
+     * Updates an OAuth application
+     * @return Promise for the updated OAuth application
+     */
+    update(): Promise<OAuthApplicationProps>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw OAuth application data
+ * @return Wrapped OAuth application data
+ */
+export declare function wrapOAuthApplication(makeRequest: MakeRequest, data: OAuthApplicationProps, userId: string): OAuthApplication;
+/**
+ * @private
+ */
+export declare const wrapOAuthApplicationCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CursorPaginatedCollectionProp<OAuthApplicationProps>, userId: string) => import("../common-types.js").CursorPaginatedCollection<OAuthApplication, OAuthApplicationProps>;
+export {};

package/dist/types/entities/oauth-application.js

@@ -0,0 +1,63 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import copy from 'fast-copy';
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+
+var ScopeValues;
+(function (ScopeValues) {
+    ScopeValues["Read"] = "content_management_read";
+    ScopeValues["Manage"] = "content_management_manage";
+})(ScopeValues || (ScopeValues = {}));
+/**
+ * @private
+ */
+function createOAuthApplicationApi(makeRequest, userId) {
+    const getParams = (data) => ({
+        userId,
+        oauthApplicationId: data.sys.id,
+    });
+    return {
+        /**
+         * Updates an OAuth application
+         * @return Promise for the updated OAuth application
+         */
+        async update() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OAuthApplication',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            });
+        },
+        /**
+         * Deletes an OAuth application
+         * @return Promise for the deleted OAuth application
+         */
+        async delete() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OAuthApplication',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw OAuth application data
+ * @return Wrapped OAuth application data
+ */
+function wrapOAuthApplication(makeRequest, data, userId) {
+    const oauthApplication = toPlainObject(copy(data));
+    const oauthApplicationWithMethods = enhanceWithMethods(oauthApplication, createOAuthApplicationApi(makeRequest, userId));
+    return freezeSys(oauthApplicationWithMethods);
+}
+/**
+ * @private
+ */
+const wrapOAuthApplicationCollection = wrapCursorPaginatedCollection(wrapOAuthApplication);
+
+export { ScopeValues, wrapOAuthApplication, wrapOAuthApplicationCollection };

package/dist/types/entities/organization-invitation.d.ts

@@ -0,0 +1,23 @@
+import type { DefaultElements, Link, MakeRequest, MetaSysProps } from '../common-types.js';
+export type OrganizationInvitationProps = {
+    sys: MetaSysProps & {
+        organizationMembership: Link<'OrganizationMembership'>;
+        user: Record<string, any> | null;
+        invitationUrl: string;
+        status: string;
+    };
+    firstName: string;
+    lastName: string;
+    email: string;
+    role: string;
+};
+export type CreateOrganizationInvitationProps = Omit<OrganizationInvitationProps, 'sys'>;
+export interface OrganizationInvitation extends OrganizationInvitationProps, DefaultElements<OrganizationInvitationProps> {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw invitation data
+ * @return {OrganizationInvitation} Wrapped Inviation data
+ */
+export declare function wrapOrganizationInvitation(_makeRequest: MakeRequest, data: OrganizationInvitationProps): OrganizationInvitation;

package/dist/types/entities/organization-invitation.js

@@ -0,0 +1,15 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw invitation data
+ * @return {OrganizationInvitation} Wrapped Inviation data
+ */
+function wrapOrganizationInvitation(_makeRequest, data) {
+    const invitation = toPlainObject(copy(data));
+    return freezeSys(invitation);
+}
+
+export { wrapOrganizationInvitation };

package/dist/types/entities/organization-membership.d.ts

@@ -0,0 +1,67 @@
+import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types.js';
+export type OrganizationMembershipProps = {
+    /**
+     * System metadata
+     */
+    sys: MetaSysProps & {
+        user: Link<'User'>;
+    };
+    /**
+     * Role
+     */
+    role: string;
+    /**
+     * status
+     */
+    status: boolean;
+};
+export interface OrganizationMembership extends OrganizationMembershipProps, DefaultElements<OrganizationMembershipProps> {
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return Object returned from the server with updated changes.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganization('organization_id')
+     * .then(org => org.getOrganizationMembership('organizationMembership_id'))
+     * .then((organizationMembership) => {
+     *  organizationMembership.role = 'member';
+     *  organizationMembership.update();
+     * })
+     * .catch(console.error)
+     */
+    update(): Promise<OrganizationMembership>;
+    /**
+     * Deletes this object on the server.
+     * @example```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganization('organization_id')
+     * .then(org => org.getOrganizationMembership('organizationMembership_id'))
+     * .then((organizationMembership) => {
+     *  organizationMembership.delete();
+     * })
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param {function} makeRequest - function to make requests via an adapter
+ * @param {Object} data - Raw organization membership data
+ * @return {OrganizationMembership} Wrapped organization membership data
+ */
+export declare function wrapOrganizationMembership(makeRequest: MakeRequest, data: OrganizationMembershipProps, organizationId: string): OrganizationMembership;
+/**
+ * @private
+ */
+export declare const wrapOrganizationMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<OrganizationMembershipProps>, organizationId: string) => import("../common-types.js").Collection<OrganizationMembership, OrganizationMembershipProps>;

package/dist/types/entities/organization-membership.js

@@ -0,0 +1,50 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createOrganizationMembershipApi(makeRequest, organizationId) {
+    const getParams = (data) => ({
+        organizationMembershipId: data.sys.id,
+        organizationId,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OrganizationMembership',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapOrganizationMembership(makeRequest, data, organizationId));
+        },
+        delete: function del() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OrganizationMembership',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param {function} makeRequest - function to make requests via an adapter
+ * @param {Object} data - Raw organization membership data
+ * @return {OrganizationMembership} Wrapped organization membership data
+ */
+function wrapOrganizationMembership(makeRequest, data, organizationId) {
+    const organizationMembership = toPlainObject(copy(data));
+    const organizationMembershipWithMethods = enhanceWithMethods(organizationMembership, createOrganizationMembershipApi(makeRequest, organizationId));
+    return freezeSys(organizationMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapOrganizationMembershipCollection = wrapCollection(wrapOrganizationMembership);
+
+export { wrapOrganizationMembership, wrapOrganizationMembershipCollection };

package/dist/types/entities/organization.d.ts

@@ -0,0 +1,33 @@
+import type { ContentfulOrganizationAPI } from '../create-organization-api.js';
+import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
+export type Organization = DefaultElements<OrganizationProps> & OrganizationProps & ContentfulOrganizationAPI;
+export type OrganizationProps = {
+    /**
+     * System metadata
+     */
+    sys: MetaSysProps;
+    /**
+     * Name
+     */
+    name: string;
+};
+/**
+ * @deprecated Use `OrganizationProps` instead.
+ */
+export type OrganizationProp = OrganizationProps;
+/**
+ * This method creates the API for the given organization with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with an organization id, so the base path for requests now has the
+ * organization id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for an Organization
+ * @return {Organization}
+ */
+export declare function wrapOrganization(makeRequest: MakeRequest, data: OrganizationProps): Organization;
+/**
+ * This method normalizes each organization in a collection.
+ * @private
+ */
+export declare const wrapOrganizationCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<OrganizationProps>) => import("../common-types.js").Collection<Organization, OrganizationProps>;

package/dist/types/entities/organization.js

@@ -0,0 +1,29 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import createOrganizationApi from '../create-organization-api.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * This method creates the API for the given organization with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with an organization id, so the base path for requests now has the
+ * organization id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for an Organization
+ * @return {Organization}
+ */
+function wrapOrganization(makeRequest, data) {
+    const org = toPlainObject(copy(data));
+    const orgApi = createOrganizationApi(makeRequest);
+    const enhancedOrganization = enhanceWithMethods(org, orgApi);
+    return freezeSys(enhancedOrganization);
+}
+/**
+ * This method normalizes each organization in a collection.
+ * @private
+ */
+const wrapOrganizationCollection = wrapCollection(wrapOrganization);
+
+export { wrapOrganization, wrapOrganizationCollection };

package/dist/types/entities/personal-access-token.d.ts

@@ -0,0 +1,51 @@
+import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
+export type PersonalAccessTokenProps = {
+    sys: MetaSysProps & {
+        expiresAt?: string;
+    };
+    name: string;
+    scopes: 'content_management_manage'[];
+    revokedAt: null | string;
+    token?: string;
+};
+/**
+ * @deprecated Use `PersonalAccessTokenProps` instead.
+ */
+export type PersonalAccessTokenProp = PersonalAccessTokenProps;
+export type CreatePersonalAccessTokenProps = Pick<PersonalAccessToken, 'name' | 'scopes'> & {
+    expiresIn?: number;
+};
+export interface PersonalAccessToken extends PersonalAccessTokenProps, DefaultElements<PersonalAccessTokenProps> {
+    /**
+     * Revokes a personal access token
+     * @return Object the revoked personal access token
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *  accessToken: <content_management_api_key>
+     * })
+     *
+     * client.getPersonalAccessToken('<token-id>')
+     *  .then((personalAccessToken) => {
+     *    return personalAccessToken.revoke()
+     *  })
+     *  .catch(console.error)
+     * ```
+     */
+    revoke(): Promise<PersonalAccessToken>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw  personal access token data
+ * @return Wrapped personal access token
+ */
+export declare function wrapPersonalAccessToken(makeRequest: MakeRequest, data: PersonalAccessTokenProps): PersonalAccessToken;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw personal access collection data
+ * @return Wrapped personal access token collection data
+ */
+export declare const wrapPersonalAccessTokenCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<PersonalAccessTokenProps>) => import("../common-types.js").Collection<PersonalAccessToken, PersonalAccessTokenProps>;