@janbox/contentful-marketplace-sdk 2.0.0 → 3.0.0-alpha.0

package/dist/types/cms.d.ts

@@ -0,0 +1,61 @@
+export type CmsLink<T extends "Entry" | "Asset" = "Entry" | "Asset"> = {
+    sys: {
+        type: "Link";
+        linkType: T;
+        id: string;
+    };
+};
+export interface CmsEntry<F extends object = object> {
+    sys: {
+        id: string;
+        type: "Entry";
+        createdAt: string;
+        updatedAt: string;
+        contentType: {
+            sys: {
+                type: "Link";
+                linkType: "ContentType";
+                id: string;
+            };
+        };
+    };
+    fields: Partial<F>;
+}
+export interface CmsAsset {
+    sys: {
+        id: string;
+        type: "Asset";
+        createdAt: string;
+        updatedAt: string;
+    };
+    fields: {
+        title?: string;
+        description?: string;
+        file?: {
+            url: string;
+            fileName: string;
+            contentType: string;
+            details: {
+                size: number;
+                image?: {
+                    width: number;
+                    height: number;
+                };
+            };
+        };
+    };
+}
+export interface CmsCollection<T> {
+    sys: {
+        type: "Array";
+    };
+    total: number;
+    skip: number;
+    limit: number;
+    items: T[];
+    includes?: {
+        Entry?: CmsEntry[];
+        Asset?: CmsAsset[];
+    };
+    errors?: unknown[];
+}

package/dist/types/content-model.d.ts

@@ -1,163 +1,134 @@
-import { ChainModifiers, Entry, EntryFieldTypes, EntrySkeletonType, LocaleCode } from 'contentful';
+import { Document } from '@contentful/rich-text-types';
+import { CmsLink } from './cms';
 export interface TypeAuthorFields {
-    name: EntryFieldTypes.Symbol;
-    avatar?: EntryFieldTypes.AssetLink;
+    name: string;
+    avatar?: CmsLink<"Asset">;
 }
-export type TypeAuthorSkeleton = EntrySkeletonType<TypeAuthorFields, "author">;
-export type TypeAuthor<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeAuthorSkeleton, Modifiers, Locales>;
 export interface TypeBannerFields {
-    name: EntryFieldTypes.Symbol;
-    hyperlink?: EntryFieldTypes.EntryLink<TypeHyperlinkSkeleton>;
-    media: EntryFieldTypes.AssetLink;
+    name: string;
+    hyperlink?: CmsLink<"Entry">;
+    media: CmsLink<"Asset">;
 }
-export type TypeBannerSkeleton = EntrySkeletonType<TypeBannerFields, "banner">;
-export type TypeBanner<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeBannerSkeleton, Modifiers, Locales>;
 export interface TypeBannerCollectionFields {
-    name: EntryFieldTypes.Symbol;
-    banners?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeBannerSkeleton>>;
-    market?: EntryFieldTypes.EntryLink<TypeMarketSkeleton>;
-    locale?: EntryFieldTypes.Symbol;
-    platform: EntryFieldTypes.Array<EntryFieldTypes.Symbol<"MOBILE" | "WEB">>;
-    slot: EntryFieldTypes.Symbol;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-}
-export type TypeBannerCollectionSkeleton = EntrySkeletonType<TypeBannerCollectionFields, "bannerCollection">;
-export type TypeBannerCollection<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeBannerCollectionSkeleton, Modifiers, Locales>;
+    name: string;
+    banners?: CmsLink<"Entry">[];
+    locale?: string;
+    platform: ("MOBILE" | "WEB")[];
+    slot: string;
+    markets?: CmsLink<"Entry">[];
+}
 export interface TypeBlogCategoryFields {
-    title: EntryFieldTypes.Symbol;
-    slug: EntryFieldTypes.Symbol;
-    description?: EntryFieldTypes.Symbol;
-    featuredImage?: EntryFieldTypes.AssetLink;
-    locale?: EntryFieldTypes.Symbol;
-    seo?: EntryFieldTypes.EntryLink<TypeSeoSkeleton>;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-}
-export type TypeBlogCategorySkeleton = EntrySkeletonType<TypeBlogCategoryFields, "blogCategory">;
-export type TypeBlogCategory<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeBlogCategorySkeleton, Modifiers, Locales>;
+    title: string;
+    slug: string;
+    description?: string;
+    featuredImage?: CmsLink<"Asset">;
+    locale?: string;
+    seo?: CmsLink<"Entry">;
+    markets?: CmsLink<"Entry">[];
+}
 export interface TypeBlogCollectionFields {
-    name: EntryFieldTypes.Symbol;
-    type: EntryFieldTypes.Symbol<"category" | "manual">;
-    featuredImage?: EntryFieldTypes.AssetLink;
-    posts?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeBlogPostSkeleton>>;
-    category?: EntryFieldTypes.EntryLink<TypeBlogCategorySkeleton>;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-    locale?: EntryFieldTypes.Symbol;
-    order: EntryFieldTypes.Integer;
-}
-export type TypeBlogCollectionSkeleton = EntrySkeletonType<TypeBlogCollectionFields, "blogCollection">;
-export type TypeBlogCollection<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeBlogCollectionSkeleton, Modifiers, Locales>;
+    name: string;
+    type: "category" | "manual";
+    featuredImage?: CmsLink<"Asset">;
+    posts?: CmsLink<"Entry">[];
+    category?: CmsLink<"Entry">;
+    markets?: CmsLink<"Entry">[];
+    locale?: string;
+    order: number;
+}
 export interface TypeBlogPostFields {
-    title: EntryFieldTypes.Symbol;
-    shortDescription?: EntryFieldTypes.Text;
-    slug: EntryFieldTypes.Symbol;
-    author?: EntryFieldTypes.EntryLink<TypeAuthorSkeleton>;
-    featuredImage: EntryFieldTypes.AssetLink;
-    content: EntryFieldTypes.RichText;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-    locale?: EntryFieldTypes.Symbol;
-    seo?: EntryFieldTypes.EntryLink<TypeSeoSkeleton>;
-    categories?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeBlogCategorySkeleton>>;
-}
-export type TypeBlogPostSkeleton = EntrySkeletonType<TypeBlogPostFields, "blogPost">;
-export type TypeBlogPost<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeBlogPostSkeleton, Modifiers, Locales>;
+    title: string;
+    shortDescription?: string;
+    slug: string;
+    author?: CmsLink<"Entry">;
+    featuredImage: CmsLink<"Asset">;
+    content: Document;
+    markets?: CmsLink<"Entry">[];
+    locale?: string;
+    seo?: CmsLink<"Entry">;
+    categories?: CmsLink<"Entry">[];
+}
 export interface TypeBrandFields {
-    name: EntryFieldTypes.Symbol;
-    logo?: EntryFieldTypes.AssetLink;
-    hyperlink?: EntryFieldTypes.EntryLink<TypeHyperlinkSkeleton>;
+    name: string;
+    logo?: CmsLink<"Asset">;
+    hyperlink?: CmsLink<"Entry">;
 }
-export type TypeBrandSkeleton = EntrySkeletonType<TypeBrandFields, "brand">;
-export type TypeBrand<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeBrandSkeleton, Modifiers, Locales>;
 export interface TypeBrandCollectionFields {
-    name: EntryFieldTypes.Symbol;
-    brands?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeBrandSkeleton>>;
-    market?: EntryFieldTypes.EntryLink<TypeMarketSkeleton>;
-    locale?: EntryFieldTypes.Symbol;
-    slot: EntryFieldTypes.Symbol<"footer">;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-}
-export type TypeBrandCollectionSkeleton = EntrySkeletonType<TypeBrandCollectionFields, "brandCollection">;
-export type TypeBrandCollection<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeBrandCollectionSkeleton, Modifiers, Locales>;
+    name: string;
+    brands?: CmsLink<"Entry">[];
+    market?: CmsLink<"Entry">;
+    locale?: string;
+    slot: "footer";
+    markets?: CmsLink<"Entry">[];
+}
 export interface TypeDocumentationArticleFields {
-    title: EntryFieldTypes.Symbol;
-    slug: EntryFieldTypes.Symbol;
-    content: EntryFieldTypes.RichText;
-    author?: EntryFieldTypes.EntryLink<TypeAuthorSkeleton>;
-    category: EntryFieldTypes.EntryLink<TypeDocumentationCategorySkeleton>;
-    market?: EntryFieldTypes.EntryLink<TypeMarketSkeleton>;
-    locale?: EntryFieldTypes.Symbol;
-    seo?: EntryFieldTypes.EntryLink<TypeSeoSkeleton>;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-}
-export type TypeDocumentationArticleSkeleton = EntrySkeletonType<TypeDocumentationArticleFields, "documentationArticle">;
-export type TypeDocumentationArticle<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeDocumentationArticleSkeleton, Modifiers, Locales>;
+    title: string;
+    slug: string;
+    content: Document;
+    author?: CmsLink<"Entry">;
+    category: CmsLink<"Entry">;
+    market?: CmsLink<"Entry">;
+    locale?: string;
+    seo?: CmsLink<"Entry">;
+    markets?: CmsLink<"Entry">[];
+}
 export interface TypeDocumentationCategoryFields {
-    title: EntryFieldTypes.Symbol;
-    slug: EntryFieldTypes.Symbol;
-    description?: EntryFieldTypes.Symbol;
-    order?: EntryFieldTypes.Integer;
-    market?: EntryFieldTypes.EntryLink<TypeMarketSkeleton>;
-    locale?: EntryFieldTypes.Symbol;
-    seo?: EntryFieldTypes.EntryLink<TypeSeoSkeleton>;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-}
-export type TypeDocumentationCategorySkeleton = EntrySkeletonType<TypeDocumentationCategoryFields, "documentationCategory">;
-export type TypeDocumentationCategory<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeDocumentationCategorySkeleton, Modifiers, Locales>;
+    title: string;
+    slug: string;
+    description?: string;
+    order?: number;
+    market?: CmsLink<"Entry">;
+    locale?: string;
+    seo?: CmsLink<"Entry">;
+    markets?: CmsLink<"Entry">[];
+}
 export interface TypeHyperlinkFields {
-    label: EntryFieldTypes.Symbol;
-    url: EntryFieldTypes.Symbol;
-    target: EntryFieldTypes.Symbol<"_blank" | "_self">;
-    marketHandling: EntryFieldTypes.Symbol<"auto" | "manual">;
+    label: string;
+    url: string;
+    target: "_blank" | "_self";
+    marketHandling: "auto" | "manual";
 }
-export type TypeHyperlinkSkeleton = EntrySkeletonType<TypeHyperlinkFields, "hyperlink">;
-export type TypeHyperlink<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeHyperlinkSkeleton, Modifiers, Locales>;
 export interface TypeHyperlinkCollectionFields {
-    name: EntryFieldTypes.Symbol;
-    links?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeHyperlinkSkeleton>>;
-    market?: EntryFieldTypes.EntryLink<TypeMarketSkeleton>;
-    locale?: EntryFieldTypes.Symbol;
-    slot: EntryFieldTypes.Symbol<"footer">;
-    order: EntryFieldTypes.Integer;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-}
-export type TypeHyperlinkCollectionSkeleton = EntrySkeletonType<TypeHyperlinkCollectionFields, "hyperlinkCollection">;
-export type TypeHyperlinkCollection<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeHyperlinkCollectionSkeleton, Modifiers, Locales>;
+    name: string;
+    links?: CmsLink<"Entry">[];
+    market?: CmsLink<"Entry">;
+    locale?: string;
+    slot: "footer";
+    order: number;
+    markets?: CmsLink<"Entry">[];
+}
 export interface TypeKeywordCollectionFields {
-    name: EntryFieldTypes.Symbol;
-    keywords?: EntryFieldTypes.Array<EntryFieldTypes.Symbol>;
-    market?: EntryFieldTypes.EntryLink<TypeMarketSkeleton>;
-    locale?: EntryFieldTypes.Symbol;
-    slot: EntryFieldTypes.Symbol<"footer">;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-}
-export type TypeKeywordCollectionSkeleton = EntrySkeletonType<TypeKeywordCollectionFields, "keywordCollection">;
-export type TypeKeywordCollection<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeKeywordCollectionSkeleton, Modifiers, Locales>;
+    name: string;
+    keywords?: string[];
+    market?: CmsLink<"Entry">;
+    locale?: string;
+    slot: "footer";
+    markets?: CmsLink<"Entry">[];
+}
 export interface TypeLanguageFields {
-    name: EntryFieldTypes.Symbol;
-    code: EntryFieldTypes.Symbol;
+    name: string;
+    code: string;
 }
-export type TypeLanguageSkeleton = EntrySkeletonType<TypeLanguageFields, "language">;
-export type TypeLanguage<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeLanguageSkeleton, Modifiers, Locales>;
 export interface TypeMarketFields {
-    name: EntryFieldTypes.Symbol;
-    code: EntryFieldTypes.Symbol;
+    name: string;
+    code: string;
 }
-export type TypeMarketSkeleton = EntrySkeletonType<TypeMarketFields, "market">;
-export type TypeMarket<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeMarketSkeleton, Modifiers, Locales>;
 export interface TypeNoticeFields {
-    title: EntryFieldTypes.Symbol;
-    content: EntryFieldTypes.RichText;
-    market?: EntryFieldTypes.EntryLink<TypeMarketSkeleton>;
-    locale?: EntryFieldTypes.Symbol;
-    variant?: EntryFieldTypes.Array<EntryFieldTypes.Symbol<"Featured" | "Promotion" | "Urgent">>;
-    markets?: EntryFieldTypes.Array<EntryFieldTypes.EntryLink<TypeMarketSkeleton>>;
-}
-export type TypeNoticeSkeleton = EntrySkeletonType<TypeNoticeFields, "notice">;
-export type TypeNotice<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeNoticeSkeleton, Modifiers, Locales>;
+    title: string;
+    content: Document;
+    locale?: string;
+    variant?: ("featured" | "promotion" | "urgent")[];
+    markets?: CmsLink<"Entry">[];
+}
+export interface TypePolicyAndTermsFields {
+    title: string;
+    content?: Document;
+    locale?: string;
+    markets?: CmsLink<"Entry">[];
+}
 export interface TypeSeoFields {
-    metaTitle: EntryFieldTypes.Symbol;
-    metaDescription?: EntryFieldTypes.Text;
-    metaKeywords?: EntryFieldTypes.Array<EntryFieldTypes.Symbol>;
-    metaRobots?: EntryFieldTypes.Array<EntryFieldTypes.Symbol<"follow" | "index" | "nofollow" | "noindex">>;
+    metaTitle: string;
+    metaDescription?: string;
+    metaKeywords?: string[];
+    metaRobots?: ("follow" | "index" | "nofollow" | "noindex")[];
 }
-export type TypeSeoSkeleton = EntrySkeletonType<TypeSeoFields, "seo">;
-export type TypeSeo<Modifiers extends ChainModifiers, Locales extends LocaleCode = LocaleCode> = Entry<TypeSeoSkeleton, Modifiers, Locales>;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-import { EntrySys } from 'contentful';
+export * from './cms';
 export * from './content-model';
 export type GraphQLAsset = {
     url: string;
@@ -7,5 +7,7 @@ export type GraphQLAsset = {
     contentType: string;
 };
 export type GraphQLAssetLink = GraphQLAsset & {
-    sys: Pick<EntrySys, "id">;
+    sys: {
+        id: string;
+    };
 };

package/dist/utils/query.d.ts

@@ -0,0 +1,17 @@
+export type QueryParams = Record<string, string | number | undefined>;
+export declare const DEFAULT_ORDER = "-sys.updatedAt";
+export declare const marketFilter: (marketCode?: string) => QueryParams;
+export declare const localeFilter: (locale?: string) => QueryParams;
+export declare const detailFilter: ({ id, slug }: {
+    id?: string;
+    slug?: string;
+}) => QueryParams;
+export declare const paging: (page: number, size: number, extraSkip?: number) => {
+    page: number;
+    size: number;
+    params: {
+        limit: number;
+        skip: number;
+    };
+};
+export declare const toSearchParams: (params: QueryParams) => URLSearchParams;

package/dist/utils/resolve.d.ts

@@ -0,0 +1,31 @@
+import { Document } from '@contentful/rich-text-types';
+import { HyperlinkGraphQLItem } from '../entries/hyperlink';
+import { GraphQLSeo } from '../entries/seo';
+import { CmsAsset, CmsCollection, CmsEntry, CmsLink, GraphQLAsset, GraphQLAssetLink, TypeAuthorFields, TypeHyperlinkFields, TypeSeoFields } from '../types';
+export type Resolver = {
+    entry<F extends object>(link?: CmsLink): CmsEntry<F> | null;
+    asset(link?: CmsLink): CmsAsset | null;
+    entries<F extends object>(links?: CmsLink[]): CmsEntry<F>[];
+};
+export type RichText = {
+    json: Document;
+    links: {
+        assets: {
+            block: GraphQLAssetLink[];
+        };
+    };
+};
+export declare const createResolver: (collection: CmsCollection<CmsEntry>) => Resolver;
+export declare const orNull: <T>(value: T | undefined) => T | null;
+export declare const toAsset: (asset: CmsAsset | null) => GraphQLAsset | null;
+export declare const toAssetLink: (asset: CmsAsset) => GraphQLAssetLink & {
+    title: string | null;
+    description: string | null;
+};
+export declare const toRichText: (document: Document | undefined, resolver: Resolver) => RichText | null;
+export declare const toSeo: (entry: CmsEntry<TypeSeoFields> | null) => GraphQLSeo | null;
+export declare const toHyperlinkItem: (entry: CmsEntry<TypeHyperlinkFields> | null) => HyperlinkGraphQLItem | null;
+export declare const toAuthorItem: (entry: CmsEntry<TypeAuthorFields> | null, resolver: Resolver) => {
+    name: string;
+    avatar: GraphQLAsset | null;
+} | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@janbox/contentful-marketplace-sdk",
-  "version": "2.0.0",
+  "version": "3.0.0-alpha.0",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,9 +16,6 @@
   },
   "type": "module",
   "sideEffects": false,
-  "devDependencies": {
-    "contentful": "^11.7.17"
-  },
   "scripts": {
     "dev": "vite",
     "build": "tsc -p tsconfig.build.json && vite build",
@@ -26,5 +23,8 @@
     "test": "vitest",
     "test:ui": "vitest --ui",
     "test:coverage": "vitest --coverage"
+  },
+  "dependencies": {
+    "@contentful/rich-text-types": "^16.8.5"
   }
-}
+}