@dalmore/api-contracts 1.0.5 → 1.0.6

package/src/common/types/site-link.types.spec.ts

@@ -0,0 +1,134 @@
+import {
+  SiteLinkType,
+  PostSiteLinkZod,
+  createSocialMediaUrlSchema,
+} from './site-link.types';
+
+describe('PostSiteLinkZod', () => {
+  it('should validate a valid Facebook link', () => {
+    const validData = {
+      type: SiteLinkType.FACEBOOK,
+      url: 'https://facebook.com/validpage',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a valid LinkedIn link', () => {
+    const validData = {
+      type: SiteLinkType.LINKEDIN,
+      url: 'https://linkedin.com/in/validprofile',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a valid Twitter link', () => {
+    const validData = {
+      type: SiteLinkType.TWITTER,
+      url: 'https://twitter.com/validhandle',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate when url is null', () => {
+    const validData = {
+      type: SiteLinkType.FACEBOOK,
+      url: null,
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate when url is undefined', () => {
+    const validData = {
+      type: SiteLinkType.FACEBOOK,
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a WEBSITE type with any valid URL', () => {
+    const validData = {
+      type: SiteLinkType.WEBSITE,
+      url: 'https://example.com',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate an OTHER type with any valid URL', () => {
+    const validData = {
+      type: SiteLinkType.OTHER,
+      url: 'https://example.org',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject an invalid Facebook URL', () => {
+    const invalidData = {
+      type: SiteLinkType.FACEBOOK,
+      url: 'https://not-facebook.com/profile',
+    };
+
+    const result = PostSiteLinkZod.safeParse(invalidData);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0]!.path).toContain('url');
+    }
+  });
+
+  it('should reject an invalid URL format', () => {
+    const invalidData = {
+      type: SiteLinkType.WEBSITE,
+      url: 'not-a-valid-url',
+    };
+
+    const result = PostSiteLinkZod.safeParse(invalidData);
+    expect(result.success).toBe(false);
+  });
+
+  it('should require type field', () => {
+    const invalidData = {
+      url: 'https://example.com',
+    };
+
+    const result = PostSiteLinkZod.safeParse(invalidData as any);
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('createSocialMediaUrlSchema', () => {
+  it('should validate a correct Facebook URL', () => {
+    const schema = createSocialMediaUrlSchema(SiteLinkType.FACEBOOK);
+    const result = schema.safeParse('https://facebook.com/validpage');
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a correct Facebook URL with www', () => {
+    const schema = createSocialMediaUrlSchema(SiteLinkType.FACEBOOK);
+    const result = schema.safeParse('https://www.facebook.com/validpage');
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject an incorrect Facebook URL', () => {
+    const schema = createSocialMediaUrlSchema(SiteLinkType.FACEBOOK);
+    const result = schema.safeParse('https://not-facebook.com/profile');
+    expect(result.success).toBe(false);
+  });
+
+  it('should handle null values', () => {
+    const schema = createSocialMediaUrlSchema(SiteLinkType.FACEBOOK);
+    const result = schema.safeParse(null);
+    expect(result.success).toBe(true);
+  });
+});

package/src/common/types/site-link.types.ts

@@ -0,0 +1,166 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+import { sitesIdSchema, SiteZod } from './site.types';
+import { IPaginationMeta } from './common.types';
+
+extendZodWithOpenApi(z);
+
+export enum SiteLinkType {
+  'FACEBOOK' = 'FACEBOOK',
+  'TWITTER' = 'TWITTER',
+  'LINKEDIN' = 'LINKEDIN',
+  'INSTAGRAM' = 'INSTAGRAM',
+  'WEBSITE' = 'WEBSITE',
+  'OTHER' = 'OTHER',
+}
+
+export const siteLinkIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'site_link';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid site link ID format. Must be a valid TypeID with "site_link" prefix. Example: site_link_01j5y5ghx5fg68d663j1fvy2x7`,
+  },
+);
+
+// Social media URL validation configuration
+const SOCIAL_MEDIA_CONFIGS = {
+  TWITTER: {
+    domains: ['twitter.com', 'x.com'],
+    protocol: 'https://',
+    message: 'Must be a valid Twitter/X URL',
+  },
+  LINKEDIN: {
+    domains: ['linkedin.com', 'www.linkedin.com'],
+    protocol: 'https://',
+    message: 'Must be a valid LinkedIn URL',
+  },
+  FACEBOOK: {
+    domains: ['facebook.com', 'www.facebook.com'],
+    protocol: 'https://',
+    message: 'Must be a valid Facebook URL',
+  },
+  INSTAGRAM: {
+    domains: ['instagram.com', 'www.instagram.com'],
+    protocol: 'https://',
+    message: 'Must be a valid Instagram URL',
+  },
+} as const;
+
+type SocialMediaType = keyof typeof SOCIAL_MEDIA_CONFIGS;
+
+/**
+ * Creates a Zod schema for validating social media URLs
+ * @param type - The type of social media platform
+ * @returns A Zod schema that validates URLs for the specified platform
+ */
+export const createSocialMediaUrlSchema = (type: SocialMediaType) => {
+  const config = SOCIAL_MEDIA_CONFIGS[type];
+
+  return z
+    .union([
+      z
+        .string()
+        .url()
+        .refine(
+          (url) =>
+            config.domains.some((domain) =>
+              url.startsWith(`${config.protocol}${domain}/`),
+            ),
+          { message: config.message },
+        ),
+      z.null(),
+    ])
+    .optional();
+};
+
+export const ISiteLink = IBaseEntity.extend({
+  type: z.nativeEnum(SiteLinkType),
+  url: z.string().url().nullable(),
+  siteId: z.lazy(() => sitesIdSchema).nullable(),
+  site: z.lazy(() => SiteZod).nullable(),
+});
+
+export type ISiteLink = z.infer<typeof ISiteLink>;
+
+export const PostSiteLinkZod = z
+  .object({
+    type: z
+      .nativeEnum(SiteLinkType)
+      .openapi({ example: SiteLinkType.FACEBOOK }),
+    url: z.string().url().nullable().optional(),
+  })
+  .refine(
+    (data) => {
+      if (!data.url) return true;
+      if (data.type in SOCIAL_MEDIA_CONFIGS) {
+        const schema = createSocialMediaUrlSchema(data.type as SocialMediaType);
+        try {
+          schema.parse(data.url);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      return true;
+    },
+    {
+      message: 'URL must be valid for the selected social media platform',
+      path: ['url'],
+    },
+  );
+
+export type PostSiteLinkZod = z.infer<typeof PostSiteLinkZod>;
+
+export const SiteLinkFiltersZod = z.object({
+  type: z.nativeEnum(SiteLinkType).nullable().optional(),
+});
+
+export type SiteLinkFiltersZod = z.infer<typeof SiteLinkFiltersZod>;
+
+export const IPaginatedSiteLink = z.object({
+  items: z.array(ISiteLink),
+  meta: IPaginationMeta,
+});
+
+export type IPaginatedSiteLink = z.infer<typeof IPaginatedSiteLink>;
+
+export const SiteLinkDeleteResponse = z.object({
+  message: z.string(),
+});
+
+export type SiteLinkDeleteResponse = z.infer<typeof SiteLinkDeleteResponse>;
+
+export const siteLinksInclude = z.enum(['site']);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(UsersIncludeQuery),
+ */
+export const SiteLinksIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          siteLinksInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${siteLinksInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${siteLinksInclude.options.join(',')}`,
+    }),
+});
+
+export type SiteLinksIncludeQuery = z.infer<typeof SiteLinksIncludeQuery>;