@or-sdk/library-types-v1 3.3.1-buildtypes652.0

package/src/Categories/param.ts

@@ -0,0 +1,11 @@
+import { z } from 'nestjs-zod/z';
+import { PackageTypeEnum } from '@or-sdk/library-prisma';
+
+export const CategoryUniversalParam = z.object({
+  type: z.nativeEnum(PackageTypeEnum),
+});
+
+export const UpdateCategoryParam = z.object({
+  type: z.nativeEnum(PackageTypeEnum),
+  id: z.string().uuid(),
+});

package/src/Categories/response.dto.ts

@@ -0,0 +1,10 @@
+import { createZodDto } from 'nestjs-zod';
+import * as response from './response';
+
+export class CategoryItemResponseDTO extends createZodDto(
+  response.CategoryItemResponse,
+) {}
+
+export class CategoryListResponseDTO extends createZodDto(
+  response.CategoryListResponse,
+) {}

package/src/Categories/response.ts

@@ -0,0 +1,14 @@
+import { PackageTypeEnum } from '@or-sdk/library-prisma';
+import { z } from 'nestjs-zod/z';
+
+export const CategoryItemResponse = z.object({
+  id: z.string(),
+  name: z.string(),
+  hidden: z.boolean().optional(),
+  type: z.nativeEnum(PackageTypeEnum).optional(),
+});
+
+export const CategoryListResponse = z.object({
+  categories: z.array(CategoryItemResponse),
+  type: z.nativeEnum(PackageTypeEnum).optional(),
+});

package/src/PackageMeta.ts

@@ -0,0 +1,19 @@
+import { z } from 'nestjs-zod/z';
+
+export const PackageMeta = z
+  .intersection(
+    z.object({
+      label: z.string().trim().optional(),
+      id: z.string().trim().optional(),
+      version: z.string().trim().optional(),
+      categories: z.array(z.string()).optional(),
+      description: z.string().trim().nullable().optional(),
+      icon: z.string().trim().nullable().optional(),
+      iconType: z.string().trim().nullable().optional(),
+      recommendedSteps: z.array(z.string()).nullable().optional(),
+      shape: z.string().trim().nullable().optional(),
+      tags: z.array(z.string().trim()).nullable().optional(),
+    }),
+    z.record(z.any(), z.any()),
+  )
+  .optional();

package/src/Packages/body.dto.ts

@@ -0,0 +1,12 @@
+import { createZodDto } from 'nestjs-zod';
+import * as body from './body';
+
+export class CreatePackageByVersionBodyDTO extends createZodDto(
+  body.CreatePackageByVersionBody,
+) {}
+export class CreatePackageReleaseBodyDTO extends createZodDto(
+  body.CreatePackageReleaseBody,
+) {}
+export class CreatePackageFromJsonBodyDTO extends createZodDto(
+  body.CreatePackageFromJsonBody,
+) {}

package/src/Packages/body.ts

@@ -0,0 +1,88 @@
+import {
+  PackageSchemaTypeEnum,
+  PackageStatusDetailsLevelEnum,
+  PackageStatusDetailsStatusEnum,
+} from '@or-sdk/library-prisma';
+import { PackageMeta } from '../PackageMeta';
+import { z } from 'nestjs-zod/z';
+
+export const CreatePackageByVersionBody = z
+  .object({
+    fileName: z.string().trim().optional(),
+    fileNames: z.array(z.string()).optional(),
+    name: z.string().trim().optional(),
+    label: z.string().trim().optional(),
+    description: z.string().optional(),
+    categories: z.array(z.string()).optional(),
+    packageMeta: PackageMeta.optional(),
+    revisionId: z.string().optional(),
+    status: z
+      .nativeEnum(PackageStatusDetailsStatusEnum)
+      .default(PackageStatusDetailsStatusEnum.BETA)
+      .optional(),
+    level: z
+      .nativeEnum(PackageStatusDetailsLevelEnum)
+      .default(PackageStatusDetailsLevelEnum.ACCOUNT)
+      .optional(),
+    servingType: z
+      .string()
+      .optional()
+      .transform((s) => s?.toUpperCase?.()),
+  })
+  .transform((body) => {
+    body.label = body.label || body.name;
+
+    return body;
+  });
+
+export const CreatePackageReleaseBody = z
+  .object({
+    status: z
+      .string()
+      .transform(
+        (status) => PackageStatusDetailsStatusEnum?.[status?.toUpperCase?.()],
+      )
+      .optional(),
+    releaseNotes: z
+      .union([
+        z.string(),
+        z
+          .object({
+            markdown: z.string().optional(),
+          })
+          .transform((s) => s?.markdown || ''),
+      ])
+      .transform((s) => s?.trim?.() || s)
+      .optional(),
+    membersAccountIds: z.array(z.string()).optional(),
+    membersUserIds: z.array(z.string()).optional(),
+    member: z
+      .object({
+        account: z
+          .array(
+            z.object({
+              accountId: z.string(),
+            }),
+          )
+          .optional(),
+      })
+      .optional(),
+  })
+  .transform((body) => {
+    if (!body?.membersAccountIds?.length) {
+      body.membersAccountIds =
+        body.member?.account.map((e) => e.accountId) || [];
+    }
+
+    return body;
+  });
+
+export const CreatePackageFromJsonBody = z.object({
+  name: z.string(),
+  description: z.string(),
+  categories: z.array(z.string()).optional(),
+  packageMeta: PackageMeta.optional(),
+  data: z.any().optional(),
+  schemaType: z.nativeEnum(PackageSchemaTypeEnum),
+  isBeta: z.boolean().optional(),
+});

package/src/Packages/index.ts

@@ -0,0 +1,11 @@
+export * from './param';
+export * from './param.dto';
+
+export * from './body';
+export * from './body.dto';
+
+export * from './union';
+export * from './union.dto';
+
+export * from './response';
+export * from './response.dto';

package/src/Packages/param.dto.ts

@@ -0,0 +1,30 @@
+import { createZodDto } from 'nestjs-zod';
+import * as params from './param';
+
+export class PackageParamUniversalDTO extends createZodDto(
+  params.PackageParamUniversal,
+) {}
+
+export class CreateReleaseParamsDTO extends createZodDto(
+  params.CreateReleaseParams,
+) {}
+
+export class GetPackagesQueryDTO extends createZodDto(
+  params.GetPackagesQuery,
+) {}
+
+export class GetPackagesQueryFilterDTO extends createZodDto(
+  params.GetPackagesQueryFilter,
+) {}
+
+export class PackageParamNpmScopeDTO extends createZodDto(
+  params.PackageParamNpmScope,
+) {}
+
+export class PackageIncludesParamsDTO extends createZodDto(
+  params.PackageIncludesParams,
+) {}
+
+export class PackageSetSystemStatusParamsDTO extends createZodDto(
+  params.PackageSetSystemStatusParams,
+) {}

package/src/Packages/param.ts

@@ -0,0 +1,181 @@
+import {
+  Prisma,
+  PackageSchemaTypeEnum,
+  PackageTypeEnum,
+  PackageStatusDetailsLevelEnum,
+} from '@or-sdk/library-prisma';
+import { z } from 'nestjs-zod/z';
+import { packageLevel, packageStatus } from './propTransformer';
+
+function clearArray<T>(arr = []) {
+  return arr
+    .map((e) => e?.trim?.())
+    .filter(
+      (item) =>
+        ['', 'undefined', 'false', 'true', 'null'].indexOf(`${item}`) === -1,
+    ) as T[];
+}
+
+export enum PackagesOrderByEnum {
+  createdAt = 'createdAt',
+  created = 'created', // override
+  updatedAt = 'updatedAt',
+}
+
+export const GetPackagesQueryFilter = z.object({
+  filter: z
+    .object({
+      id: z
+        .array(z.string())
+        .or(z.string())
+        .transform((data) => clearArray(Array.isArray(data) ? data : [data]))
+        .default([]),
+      schemaType: z.nativeEnum(PackageSchemaTypeEnum).optional(),
+      category: z
+        .array(z.string())
+        .or(z.string())
+        .default([])
+        .transform((data) => (Array.isArray(data) ? data : [data])),
+      level: z
+        .array(z.nativeEnum(PackageStatusDetailsLevelEnum))
+        .or(
+          z
+            .nativeEnum(PackageStatusDetailsLevelEnum)
+            .transform((data) => [data]),
+        )
+        .default([
+          PackageStatusDetailsLevelEnum.PDE,
+          PackageStatusDetailsLevelEnum.ACCOUNT,
+        ])
+        .transform((data) => (Array.isArray(data) ? data : [data])),
+    })
+    .default({}),
+});
+
+export const GetPackagesQuery = z
+  .intersection(
+    GetPackagesQueryFilter,
+    z
+      .object({
+        id: z
+          .string()
+          .optional()
+          .transform((s) => s?.trim?.() || s || false),
+        type: z.nativeEnum(PackageTypeEnum).optional(),
+        query: z
+          .string()
+          .optional()
+          .transform((s) => (typeof s === 'string' ? s.trim() : s)),
+        scope: z
+          .object({
+            id: z
+              .array(z.string())
+              .or(z.string())
+              .transform((data) =>
+                clearArray(Array.isArray(data) ? data : [data]),
+              )
+              .default([]),
+            category: z
+              .array(z.string())
+              .or(z.string())
+              .transform((data) =>
+                clearArray(Array.isArray(data) ? data : [data]),
+              )
+              .default([]),
+          })
+          .default({}),
+        size: z
+          .number()
+          .or(z.string())
+          .default(10)
+          .transform((n) => Number(n) || 0),
+        cursor: z
+          .object({
+            from: z
+              .number()
+              .or(z.string())
+              .transform((n) => Number(n) || 0),
+          })
+          .or(z.any().transform(() => ({ from: 0 })))
+          .transform((data) => (data?.from ? data : { from: 0 })),
+        orderBy: z
+          .nativeEnum(PackagesOrderByEnum)
+          .default(PackagesOrderByEnum.createdAt)
+          .transform((data) => {
+            if (data === PackagesOrderByEnum.created) {
+              return PackagesOrderByEnum.createdAt;
+            }
+            return data;
+          }),
+        order: z.nativeEnum(Prisma.SortOrder).default(Prisma.SortOrder.desc),
+        categories: z
+          .array(z.string())
+          .default([])
+          .transform((data) => clearArray(data)),
+        includeDeprecated: z
+          .string()
+          .transform((v) => ['true', '1', 1, true].includes(v))
+          .or(z.boolean())
+          .default(false),
+      })
+      .default({}),
+  )
+  .transform((data) => {
+    return {
+      ...data,
+      categories: [
+        ...(data.scope?.category || []),
+        ...(data.filter?.category || []),
+      ],
+    };
+  });
+
+export const PackageParamUniversal = z.object({
+  type: z.nativeEnum(PackageTypeEnum),
+  id: z.string(),
+  version: z.string().optional(),
+  revisionId: z.string().optional(),
+});
+
+export const CreateReleaseParams = z.object({
+  type: z.nativeEnum(PackageTypeEnum),
+  id: z.string(),
+  revisionId: z.string().optional(),
+  version: z.string().optional(),
+  level: packageLevel,
+});
+
+export const PackageParamNpmScope = z.object({
+  npmScope: z.string(),
+});
+
+export const PackageIncludesParams = z.object({
+  includeDeprecated: z
+    .string()
+    .transform((v) => ['true', '1', 1, true].includes(v))
+    .or(z.boolean())
+    .default(true),
+  includeMember: z
+    .string()
+    .transform((v) => ['true', '1', 1, true].includes(v))
+    .or(z.boolean())
+    .default(true),
+  includeReleaseNotes: z
+    .string()
+    .transform((v) => ['true', '1', 1, true].includes(v))
+    .or(z.boolean())
+    .default(true),
+  includeData: z
+    .string()
+    .transform((v) => ['true', '1', 1, true].includes(v))
+    .or(z.boolean())
+    .default(true),
+});
+
+export const PackageSetSystemStatusParams = z.object({
+  type: z.nativeEnum(PackageTypeEnum),
+  id: z.string(),
+  version: z.string().optional(),
+  revisionId: z.string().optional(),
+  status: packageStatus,
+});

package/src/Packages/propTransformer.ts

@@ -0,0 +1,17 @@
+import { z } from 'nestjs-zod/z';
+import {
+  PackageStatusDetailsLevelEnum,
+  PackageStatusDetailsStatusEnum,
+} from '@or-sdk/library-prisma';
+
+export const packageStatus = z
+  .string()
+  .trim()
+  .toUpperCase()
+  .transform((status) => PackageStatusDetailsStatusEnum?.[status] || null);
+
+export const packageLevel = z
+  .string()
+  .trim()
+  .toUpperCase()
+  .transform((level) => PackageStatusDetailsLevelEnum?.[level] || null);

package/src/Packages/response.dto.ts

@@ -0,0 +1,38 @@
+import { createZodDto } from 'nestjs-zod';
+import * as response from './response';
+
+export class GetPackagesResponseDTO extends createZodDto(
+  response.GetPackagesResponse,
+) {}
+
+export class GetPackagesResponseEntityDTO extends createZodDto(
+  response.GetPackagesResponseEntity,
+) {}
+
+export class GetPackageResponseDTO extends createZodDto(
+  response.GetPackageResponse,
+) {}
+
+export class GetPackageByIdResponseDTO extends createZodDto(
+  response.GetPackageByIdResponse,
+) {}
+
+export class GetPackageByIdLatestResponseDTO extends createZodDto(
+  response.GetPackageByIdLatestResponse,
+) {}
+
+export class GetPackageArchiveSignedUrlDTO extends createZodDto(
+  response.GetPackageArchiveSignedUrl,
+) {}
+
+export class CreatePackageByVersionResponseDTO extends createZodDto(
+  response.CreatePackageByVersionResponse,
+) {}
+
+export class CreatePackageByVersionFileNamesResponseDTO extends createZodDto(
+  response.CreatePackageByVersionFileNamesResponse,
+) {}
+
+export class GetPackageSystemStatusResponseDTO extends createZodDto(
+  response.GetPackageSystemStatusResponse,
+) {}

package/src/Packages/response.ts

@@ -0,0 +1,203 @@
+import {
+  PackageSchemaTypeEnum,
+  PackageStatusDetailsLevelEnum,
+  PackageStatusDetailsStatusEnum,
+  PackageTypeEnum,
+} from '@or-sdk/library-prisma';
+import { PackageMeta } from '../PackageMeta';
+import { z } from 'nestjs-zod/z';
+
+const categoriesList = z.array(
+  z.object({
+    id: z.string().nullable(),
+    count: z.number(),
+    name: z.string().optional(),
+  }),
+);
+
+export const GetPackagesResponseEntity = z.object({
+  createdAt: z.date().or(z.string()).optional(),
+  id: z.string(),
+  isExternal: z.boolean().optional(),
+  isSandbox: z.boolean().optional(),
+  latest: PackageMeta,
+  latestVersion: z.string().optional(),
+  level: z.nativeEnum(PackageStatusDetailsLevelEnum).optional(),
+  levels: z.array(z.nativeEnum(PackageStatusDetailsLevelEnum)).optional(),
+  name: z.string().optional(),
+  releases: z
+    .array(
+      z.object({
+        status: z.nativeEnum(PackageStatusDetailsStatusEnum),
+        level: z.nativeEnum(PackageStatusDetailsLevelEnum),
+        version: z.string(),
+        primaryId: z.number().optional(),
+      }),
+    )
+    .optional(),
+  latestDocId: z.any().optional(),
+  revisionId: z.string().optional(),
+  schemaType: z.nativeEnum(PackageSchemaTypeEnum),
+  status: z.string().optional(),
+  statuses: z.array(z.string()).optional(),
+  type: z.nativeEnum(PackageTypeEnum).optional(),
+  versions: z.array(z.string()),
+});
+
+export const GetPackagesResponse = z.object({
+  entities: z.array(GetPackagesResponseEntity),
+  total: z.number().optional(),
+  count: z.number().optional(), // TODO: remove this
+  offset: z.number().optional(),
+  limit: z.number().optional(),
+  cursor: z.object({
+    from: z.number(),
+  }),
+  categories: categoriesList,
+  all: z.object({
+    categories: categoriesList,
+    count: z.number(),
+  }),
+});
+
+export const PackageStatusDetails = z
+  .object({
+    release: z.object({
+      pde: z
+        .object({
+          status: z.array(z.nativeEnum(PackageStatusDetailsStatusEnum)),
+        })
+        .optional(),
+      user: z
+        .object({
+          status: z.array(z.nativeEnum(PackageStatusDetailsStatusEnum)),
+        })
+        .optional(),
+      account: z
+        .object({
+          status: z.array(z.nativeEnum(PackageStatusDetailsStatusEnum)),
+        })
+        .optional(),
+    }),
+    system: z
+      .object({
+        status: z.array(z.nativeEnum(PackageStatusDetailsStatusEnum)),
+      })
+      .optional(),
+  })
+  .optional();
+
+export const GetPackageResponse = z.object({
+  baseUrl: z.string(),
+  data: z.any(),
+  packageMeta: PackageMeta,
+  id: z.string(),
+  version: z.string(),
+  schemaType: z.nativeEnum(PackageSchemaTypeEnum),
+  revisionId: z.string().optional(),
+  status: z.nativeEnum(PackageStatusDetailsStatusEnum).optional(),
+  level: z.nativeEnum(PackageStatusDetailsLevelEnum).optional(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  categories: z.array(z.string()).optional(),
+  statusDetails: PackageStatusDetails,
+  servingType: z.string().optional(),
+});
+
+export const GetPackageByIdResponse = z.object({
+  version: z.string(),
+  baseUrl: z.string(),
+  statusDetails: PackageStatusDetails.optional(),
+  servingType: z.string().optional(),
+  releaseNotes: z
+    .object({ markdown: z.string().nullable().optional() })
+    .optional()
+    .optional(),
+  member: z
+    .object({
+      account: z
+        .array(
+          z.object({
+            accountId: z.string(),
+          }),
+        )
+        .optional(),
+      user: z
+        .array(
+          z.object({
+            userId: z.string(),
+          }),
+        )
+        .optional(),
+    })
+    .optional()
+    .describe('Deprecated for v2 version api'),
+  membersAccountIds: z.array(z.string()).optional(),
+  membersUserIds: z.array(z.string()).optional(),
+  createdAt: z.date().or(z.string()).optional(),
+  revisionId: z.string().optional(),
+  name: z.string().optional(),
+  description: z.string().nullable().optional(),
+  categories: z.array(z.string()).optional(),
+  packageMeta: PackageMeta.optional(),
+  id: z.string().optional(),
+  schemaType: z.nativeEnum(PackageSchemaTypeEnum).optional(),
+});
+
+export const GetPackageByIdLatestResponse = z.object({
+  packageMeta: PackageMeta,
+  id: z.string(),
+  schemaType: z.nativeEnum(PackageSchemaTypeEnum),
+  version: z.string(),
+  baseUrl: z.string(),
+  servingType: z.string().optional(),
+});
+
+export const GetPackageArchiveSignedUrl = z.object({
+  key: z.string(),
+  url: z.string(),
+});
+
+export const CreatePackageByVersionFileNamesResponse = z
+  .array(
+    z.object({
+      fileName: z.string(),
+      url: z.string(),
+      fields: z.any(),
+    }),
+  )
+  .optional()
+  .describe(
+    'When you upload a package with multiple files, this field will be returned',
+  );
+
+export const CreatePackageByVersionResponse = z.object({
+  revisionId: z.string().optional(),
+  isExists: z.boolean().optional(),
+  fileNames: CreatePackageByVersionFileNamesResponse,
+  url: z
+    .string()
+    .optional()
+    .describe(
+      'When you upload a package with a single file, this field will be returned',
+    ),
+  fields: z
+    .any()
+    .optional()
+    .describe(
+      'When you upload a package with a single file, this field will be returned',
+    ),
+});
+
+export const GetPackageSystemStatusResponse = z.object({
+  createdAt: z.date().or(z.string()),
+  id: z.string(),
+  revisionId: z.string(),
+  statusDetailsSystem: z.array(
+    z.object({
+      status: z.nativeEnum(PackageStatusDetailsStatusEnum),
+    }),
+  ),
+  type: z.nativeEnum(PackageTypeEnum),
+  version: z.string(),
+});

package/src/Packages/union.dto.ts

@@ -0,0 +1,18 @@
+import { createZodDto } from 'nestjs-zod';
+import * as union from './union';
+
+export class CreateReleaseUnionDTO extends createZodDto(
+  union.CreateReleaseUnion,
+) {}
+
+export class CreatePackageFromJsonUnionDTO extends createZodDto(
+  union.CreatePackageFromJsonUnion,
+) {}
+
+export class CreatePackageByVersionUnionDTO extends createZodDto(
+  union.CreatePackageByVersionUnion,
+) {}
+
+export class GetPackageByIdQueryUnionDTO extends createZodDto(
+  union.GetPackageByIdQueryUnion,
+) {}