@dalmore/api-contracts 1.0.6 → 1.0.7

package/src/common/types/page.types.ts

@@ -1,436 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { z } from 'zod';
-import { IBaseEntity } from './entity.types';
-import { IPageRevision, pageRevisionIdSchema } from './page-revision.types';
-import { TypeID } from 'typeid-js';
-import {
-  AccountZod,
-  ComplianceReview,
-  dateSchema,
-  IPaginationMeta,
-  PaginationOptionsZod,
-  SortBy,
-  SortOrder,
-  UrlSchema,
-} from './common.types';
-import { accountIdSchema } from './account.types';
-import { slugify } from './contract-helpers';
-import { fileIdSchema } from './file.types';
-
-extendZodWithOpenApi(z);
-export enum PageTemplate {
-  STANDALONE = 'STANDALONE',
-  POST = 'POST',
-  PAGE = 'PAGE',
-  FILE = 'FILE',
-  URL = 'URL',
-}
-export enum PageAction {
-  DRAFT = 'DRAFT',
-  REVIEW = 'REVIEW',
-}
-export enum PageType {
-  DRAFT = 'DRAFT',
-  PUBLISHED = 'PUBLISHED',
-}
-
-export const pageIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'page';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid page ID format. Must be a valid TypeID with "page" prefix.',
-  },
-);
-export const IPage = IBaseEntity.extend({
-  id: pageIdSchema,
-  publishedVersionId: z.string().nullable(),
-  publishedVersion: IPageRevision.optional().nullable(),
-  url: z.string().nullable(),
-  publicationDate: z.date().optional().nullable(),
-  template: z.string().optional().nullable(),
-  draftVersionId: z.string().nullable(),
-  draftVersion: IPageRevision.optional().nullable(),
-  accountId: z.string().nullable(),
-  account: AccountZod.optional().nullable(),
-});
-
-export type IPage = z.infer<typeof IPage>;
-
-export const pagesInclude = z.enum([
-  'pageRevisions',
-  'publishedVersion',
-  'draftVersion',
-  'account',
-]);
-export const PagesIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          pagesInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${pagesInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${pagesInclude.options.join(',')}`,
-    }),
-});
-
-export const PagesSortZod = z.object({
-  sort: z.enum([SortBy.TITLE, SortBy.CREATED_AT, SortBy.UPDATED_AT]).optional(),
-  dir: z.nativeEnum(SortOrder).optional(),
-});
-export type PagesSortZod = z.infer<typeof PagesSortZod>;
-
-export const IPaginatedPages = z.object({
-  items: z.array(IPage),
-  meta: IPaginationMeta,
-});
-export type IPaginatedPages = z.infer<typeof IPaginatedPages>;
-
-export const ReviewPagesZod = z.object({
-  complianceReview: z
-    .enum([ComplianceReview.APPROVED, ComplianceReview.REJECTED])
-    .openapi({ example: ComplianceReview.APPROVED }),
-  pages: z.array(pageRevisionIdSchema),
-});
-
-export type ReviewPagesZod = z.infer<typeof ReviewPagesZod>;
-
-export const GetPagesZod = z.object({
-  publishedVersionId: z
-    .string()
-    .optional()
-    .nullable()
-    .transform((val) => (val === 'null' ? null : val))
-    .refine(
-      (value) => {
-        if (!value) return true;
-        try {
-          const tid = TypeID.fromString(value);
-          return tid.getType() === 'page_revision';
-        } catch {
-          return false;
-        }
-      },
-      {
-        message:
-          'Invalid page revision ID format. Must be a valid TypeID with "page_revision" prefix.',
-      },
-    )
-    .openapi({ example: 'page_revision_01je6ht4b8fbmttkzh2hs82xqp' }),
-  search: z
-    .string()
-    .min(2)
-    .max(50)
-    .optional()
-    .openapi({ example: 'News Title' }),
-  url: z
-    .string()
-    .min(2, { message: 'URL must be at least 2 characters long' })
-    .max(250, { message: 'URL must be less than 250 characters long' })
-    .nullable()
-    .optional()
-    .openapi({ example: 'news-title' }),
-  template: z
-    .nativeEnum(PageTemplate)
-    .optional()
-    .openapi({ example: PageTemplate.STANDALONE }),
-  type: z.nativeEnum(PageType).optional().openapi({ example: PageType.DRAFT }),
-  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
-  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
-  complianceReview: z.nativeEnum(ComplianceReview).optional(),
-});
-export type GetPagesZod = z.infer<typeof GetPagesZod>;
-
-export const ComplianceGetPagesZod = GetPagesZod.extend({
-  accountId: accountIdSchema.optional(),
-});
-export type ComplianceGetPagesZod = z.infer<typeof ComplianceGetPagesZod>;
-
-export const PostPageZod = z
-  .object({
-    publicationDate: z.coerce
-      .date()
-      .openapi({ example: '2024-12-24T11:23:18.752Z' }),
-    tag: z
-      .string()
-      .min(2)
-      .max(50)
-      .optional()
-      .nullable()
-      .openapi({ example: 'News Tag' }),
-    template: z
-      .nativeEnum(PageTemplate)
-      .openapi({ example: PageTemplate.STANDALONE }),
-    url: z
-      .string()
-      .min(2, { message: 'URL must be at least 2 characters long' })
-      .max(250, { message: 'URL must be less than 250 characters long' })
-      .openapi({ example: 'news-title' }),
-    title: z.string().min(2).max(200).openapi({ example: 'News Title' }),
-    body: z
-      .string()
-      .min(2)
-      .max(1000000)
-      .optional()
-      .nullable()
-      .openapi({ example: 'News Body' }),
-    author: z.string().min(2).max(50).openapi({ example: 'Author' }),
-    saveAction: z.nativeEnum(PageAction).openapi({ example: PageAction.DRAFT }),
-  })
-  .superRefine((data, ctx) => {
-    if (data.template === PageTemplate.URL) {
-      if (!z.string().url().max(256).safeParse(data.body).success) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message:
-            'body is required and must be a valid URL (max 256 chars) when template is URL',
-          path: ['body'],
-        });
-      }
-    }
-  });
-
-export type PostPageZod = z.infer<typeof PostPageZod>;
-
-export const CompliancePostPageZod = z
-  .object({
-    publicationDate: z.coerce
-      .date()
-      .openapi({ example: '2024-12-24T11:23:18.752Z' }),
-    tag: z
-      .string()
-      .min(2)
-      .max(50)
-      .optional()
-      .nullable()
-      .openapi({ example: 'News Tag' }),
-    template: z
-      .nativeEnum(PageTemplate)
-      .openapi({ example: PageTemplate.STANDALONE }),
-    url: z
-      .string()
-      .min(2, { message: 'URL must be at least 2 characters long' })
-      .max(250, { message: 'URL must be less than 250 characters long' })
-      .openapi({ example: 'news-title' }),
-    title: z.string().min(2).max(200).openapi({ example: 'News Title' }),
-    body: z
-      .string()
-      .min(2)
-      .max(1000000)
-      .optional()
-      .nullable()
-      .openapi({ example: 'News Body' }),
-    author: z.string().min(2).max(50).openapi({ example: 'Author' }),
-    saveAction: z.nativeEnum(PageAction).openapi({ example: PageAction.DRAFT }),
-    accountId: accountIdSchema.openapi({
-      example: 'account_01je6ht4b8fbmttkzh2hs82xqp',
-    }),
-  })
-  .superRefine((data, ctx) => {
-    if (data.template === PageTemplate.URL) {
-      if (!z.string().url().max(256).safeParse(data.body).success) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message:
-            'body is required and must be a valid URL (max 256 chars) when template is URL',
-          path: ['body'],
-        });
-      }
-    }
-  });
-export type CompliancePostPageZod = z.infer<typeof CompliancePostPageZod>;
-
-export const PatchPageZod = z
-  .object({
-    publicationDate: z.coerce
-      .date()
-      .optional()
-      .nullable()
-      .openapi({ example: '2024-12-24T11:23:18.752Z' }),
-    tag: z
-      .string()
-      .min(2)
-      .max(50)
-      .optional()
-      .nullable()
-      .openapi({ example: 'tag' }),
-    template: z
-      .nativeEnum(PageTemplate)
-      .optional()
-      .openapi({ example: 'template' }),
-    url: z
-      .string()
-      .min(2, { message: 'URL must be at least 2 characters long' })
-      .max(250, { message: 'URL must be less than 250 characters long' })
-      .optional()
-      .nullable()
-      .openapi({ example: 'url' }),
-    title: z
-      .string()
-      .min(2)
-      .max(200)
-      .optional()
-      .nullable()
-      .openapi({ example: 'News Title' }),
-    body: z
-      .string()
-      .min(2)
-      .max(1000000)
-      .optional()
-      .nullable()
-      .openapi({ example: 'News Body' }),
-    author: z
-      .string()
-      .min(2)
-      .max(50)
-      .optional()
-      .nullable()
-      .openapi({ example: 'Author' }),
-    coverArtId: z
-      .lazy(() => fileIdSchema)
-      .nullable()
-      .optional()
-      .openapi({ example: 'file_01je6ht4b8fbmttkzh2hs82xqp' }),
-    fileId: z
-      .lazy(() => fileIdSchema)
-      .nullable()
-      .optional()
-      .openapi({ example: 'file_01je6ht4b8fbmttkzh2hs82xqp' }),
-    saveAction: z
-      .nativeEnum(PageAction)
-      .openapi({ example: PageAction.DRAFT })
-      .optional(),
-  })
-  .superRefine((data, ctx) => {
-    if (data.template === PageTemplate.URL) {
-      if (!z.string().url().max(256).safeParse(data.body).success) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message:
-            'body must be a valid URL (max 256 chars) when template is URL',
-          path: ['body'],
-        });
-      }
-    }
-  });
-
-export type PatchPageZod = z.infer<typeof PatchPageZod>;
-
-export const UpdatePageResponseZod = z.object({
-  message: z.string(),
-});
-export type UpdatePageResponseZod = z.infer<typeof UpdatePageResponseZod>;
-
-export const IInvestorPage = IPage.transform((data) => ({
-  id: data.id,
-  url: data.url,
-  publicationDate: data.publicationDate,
-  template: data.template,
-  title: data.publishedVersion?.title,
-  author: data.publishedVersion?.author,
-  body: data.publishedVersion?.body,
-  tag: data.publishedVersion?.tag,
-  coverArtId: data.publishedVersion?.coverArtUrl,
-  coverArt: data.publishedVersion?.coverArt,
-  fileId: data.publishedVersion?.fileId,
-  file: data.publishedVersion?.file,
-}));
-
-export type IInvestorPage = z.infer<typeof IInvestorPage>;
-
-export const IPaginatedInvestorPages = z.object({
-  items: z.array(IInvestorPage),
-  meta: IPaginationMeta,
-});
-export type IPaginatedInvestorPages = z.infer<typeof IPaginatedInvestorPages>;
-
-export const GetInvestorPageByUrlZod = z.object({
-  url: z
-    .string()
-    .min(2)
-    .max(200)
-    .openapi({ example: 'news-title' })
-    .transform((val) => slugify(val)),
-});
-export type GetInvestorPageByUrlZod = z.infer<typeof GetInvestorPageByUrlZod>;
-
-export const GetInvestorPageZod = z.object({
-  type: z
-    .nativeEnum(PageTemplate)
-    .default(PageTemplate.POST)
-    .optional()
-    .openapi({ example: PageTemplate.POST }),
-  excludedPageId: pageIdSchema.optional(),
-});
-export type GetInvestorPageZod = z.infer<typeof GetInvestorPageZod>;
-
-export const IPendingPagesSummary = z.object({
-  items: z.array(
-    z.object({
-      accountId: z.string(),
-      accountName: z.string(),
-      pagesCount: z.number(),
-    }),
-  ),
-  meta: IPaginationMeta,
-});
-export type IPendingPagesSummary = z.infer<typeof IPendingPagesSummary>;
-
-export const GetLandingPageCandidate = z.object({
-  id: pageIdSchema,
-  title: z.string().nullable(),
-});
-
-export const GetLandingPageCandidatesResponse = z.array(
-  GetLandingPageCandidate,
-);
-export type GetLandingPageCandidatesResponse = z.infer<
-  typeof GetLandingPageCandidatesResponse
->;
-
-export const InvestorPageResponseZod = z.object({
-  id: pageIdSchema,
-  url: z.string().nullable(),
-  publicationDate: z.date().nullable(),
-  template: z.string().nullable(),
-  title: z.string().nullable(),
-  author: z.string().nullable(),
-  body: z.string().nullable(),
-  tag: z.string().nullable(),
-  fileUrl: z.string().nullable(),
-});
-export type InvestorPageResponseZod = z.infer<typeof InvestorPageResponseZod>;
-
-export const PublicPagesFiltersZod = PaginationOptionsZod.merge(
-  GetInvestorPageZod,
-).extend({
-  url: UrlSchema,
-});
-export type PublicPagesFiltersZod = z.infer<typeof PublicPagesFiltersZod>;
-
-export const PageAssetZod = z.object({
-  fileName: z.string(),
-  assetUrl: z.string(),
-  convertedUrl: z.string(),
-});
-export type PageAssetZod = z.infer<typeof PageAssetZod>;
-
-export const PageAssetReplacementZod = z.object({
-  find: z.string(),
-  replace: z.string(),
-});
-export type PageAssetReplacementZod = z.infer<typeof PageAssetReplacementZod>;

package/src/common/types/password.type.ts

@@ -1,15 +0,0 @@
-import { z } from 'zod';
-const passwordRegex = /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[\W_]).*$/;
-const passwordMessage =
-  'Password must be at least 8 characters and include at least one uppercase letter, one lowercase letter, one number, and one special character';
-
-export const PasswordSchema = z
-  .string()
-  .min(8, 'password is less than 8 characters')
-  .max(100, 'password is more than 100 characters')
-  .regex(passwordRegex, {
-    message: passwordMessage,
-  })
-  .openapi({
-    example: 'Secretpassword6#',
-  });