Add pl-api to workspace

Signed-off-by: marcin mikołajczak <git@mkljczk.pl>

packages/pl-api/lib/entities/admin/account.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+
+import { accountSchema } from '../account';
+import { roleSchema } from '../role';
+import { dateSchema, filteredArray } from '../utils';
+
+import { adminIpSchema } from './ip';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_Account/} */
+const adminAccountSchema = z.preprocess((account: any) => {
+  if (!account.account) {
+    /**
+     * Convert Pleroma account schema
+     * @see {@link https://docs.pleroma.social/backend/development/API/admin_api/#get-apiv1pleromaadminusers}
+     */
+    return {
+      id: account.id,
+      account: null,
+      username: account.nickname,
+      domain: account.nickname.split('@')[1] || null,
+      created_at: account.created_at,
+      email: account.email,
+      invite_request: account.registration_reason,
+      role: account.roles?.is_admin
+        ? roleSchema.parse({ name: 'Admin' })
+        : account.roles?.moderator
+          ? roleSchema.parse({ name: 'Moderator ' }) :
+          null,
+      confirmed: account.is_confirmed,
+      approved: account.is_approved,
+      disabled: !account.is_active,
+
+      actor_type: account.actor_type,
+      display_name: account.display_name,
+      suggested: account.is_suggested,
+    };
+  }
+  return account;
+}, z.object({
+  id: z.string(),
+  username: z.string(),
+  domain: z.string().nullable().catch(null),
+  created_at: dateSchema,
+  email: z.string().nullable().catch(null),
+  ip: z.string().ip().nullable().catch(null),
+  ips: filteredArray(adminIpSchema),
+  locale: z.string().nullable().catch(null),
+  invite_request: z.string().nullable().catch(null),
+  role: roleSchema.nullable().catch(null),
+  confirmed: z.boolean().catch(false),
+  approved: z.boolean().catch(false),
+  disabled: z.boolean().catch(false),
+  silenced: z.boolean().catch(false),
+  suspended: z.boolean().catch(false),
+  account: accountSchema.nullable().catch(null),
+  created_by_application_id: z.string().optional().catch(undefined),
+  invited_by_account_id: z.string().optional().catch(undefined),
+
+  actor_type: z.string().nullable().catch(null),
+  display_name: z.string().nullable().catch(null),
+  suggested: z.boolean().nullable().catch(null),
+}));
+
+type AdminAccount = z.infer<typeof adminAccountSchema>;
+
+export {
+  adminAccountSchema,
+  type AdminAccount,
+};

packages/pl-api/lib/entities/admin/announcement.ts

@@ -0,0 +1,17 @@
+import pick from 'lodash.pick';
+import { z } from 'zod';
+
+import { Resolve } from '../../utils/types';
+import { announcementSchema } from '../announcement';
+
+/** @see {@link https://docs.pleroma.social/backend/development/API/admin_api/#get-apiv1pleromaadminannouncements} */
+const adminAnnouncementSchema = z.preprocess((announcement: any) => ({
+  ...announcement,
+  ...pick(announcement.pleroma, 'raw_content'),
+}), announcementSchema.extend({
+  raw_content: z.string().catch(''),
+}));
+
+type AdminAnnouncement = Resolve<z.infer<typeof adminAnnouncementSchema>>;
+
+export { adminAnnouncementSchema, type AdminAnnouncement };

packages/pl-api/lib/entities/admin/canonical-email-block.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_CanonicalEmailBlock/} */
+const adminCanonicalEmailBlockSchema = z.object({
+  id: z.string(),
+  canonical_email_hash: z.string(),
+});
+
+type AdminCanonicalEmailBlock = z.infer<typeof adminCanonicalEmailBlockSchema>;
+
+export {
+  adminCanonicalEmailBlockSchema,
+  type AdminCanonicalEmailBlock,
+};

packages/pl-api/lib/entities/admin/cohort.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_Cohort/} */
+const adminCohortSchema = z.object({
+  period: z.string().datetime({ offset: true }),
+  frequency: z.enum(['day', 'month']),
+  data: z.array(z.object({
+    date: z.string().datetime({ offset: true }),
+    rate: z.number(),
+    value: z.number().int(),
+  })),
+});
+
+type AdminCohort = z.infer<typeof adminCohortSchema>;
+
+export {
+  adminCohortSchema,
+  type AdminCohort,
+};

packages/pl-api/lib/entities/admin/dimension.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_Dimension/} */
+const adminDimensionSchema = z.object({
+  key: z.string(),
+  data: z.object({
+    key: z.string(),
+    human_key: z.string(),
+    value: z.string(),
+    unit: z.string().optional().catch(undefined),
+    human_value: z.string().optional().catch(undefined),
+  }),
+});
+
+type AdminDimension = z.infer<typeof adminDimensionSchema>;
+
+export {
+  adminDimensionSchema,
+  type AdminDimension,
+};

packages/pl-api/lib/entities/admin/domain-allow.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+import { dateSchema } from '../utils';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_DomainAllow/} */
+const adminDomainAllowSchema = z.object({
+  id: z.string(),
+  domain: z.string(),
+  created_at: dateSchema,
+});
+
+type AdminDomainAllow = z.infer<typeof adminDomainAllowSchema>;
+
+export {
+  adminDomainAllowSchema,
+  type AdminDomainAllow,
+};

packages/pl-api/lib/entities/admin/domain-block.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+import { dateSchema } from '../utils';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_DomainBlock/} */
+const adminDomainBlockSchema = z.object({
+  id: z.string(),
+  domain: z.string(),
+  digest: z.string(),
+  created_at: dateSchema,
+  severity: z.enum(['silence', 'suspend', 'noop']),
+  reject_media: z.boolean(),
+  reject_reports: z.boolean(),
+  private_comment: z.string().nullable().catch(null),
+  public_comment: z.string().nullable().catch(null),
+  obfuscate: z.boolean(),
+});
+
+type AdminDomainBlock = z.infer<typeof adminDomainBlockSchema>;
+
+export {
+  adminDomainBlockSchema,
+  type AdminDomainBlock,
+};

packages/pl-api/lib/entities/admin/domain.ts

@@ -0,0 +1,13 @@
+import z from 'zod';
+
+const adminDomainSchema = z.object({
+  domain: z.string().catch(''),
+  id: z.coerce.string(),
+  public: z.boolean().catch(false),
+  resolves: z.boolean().catch(false),
+  last_checked_at: z.string().datetime().catch(''),
+});
+
+type AdminDomain = z.infer<typeof adminDomainSchema>
+
+export { adminDomainSchema, type AdminDomain };

packages/pl-api/lib/entities/admin/email-domain-block.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+import { dateSchema } from '../utils';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_EmailDomainBlock/} */
+const adminEmailDomainBlockSchema = z.object({
+  id: z.string(),
+  domain: z.string(),
+  created_at: dateSchema,
+  history: z.array(z.object({
+    day: z.coerce.string(),
+    accounts: z.coerce.string(),
+    uses: z.coerce.string(),
+  })),
+});
+
+type AdminEmailDomainBlock = z.infer<typeof adminEmailDomainBlockSchema>;
+
+export {
+  adminEmailDomainBlockSchema,
+  type AdminEmailDomainBlock,
+};

packages/pl-api/lib/entities/admin/ip-block.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+import { dateSchema } from '../utils';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_IpBlock/} */
+const adminIpBlockSchema = z.object({
+  id: z.string(),
+  ip: z.string().ip(),
+  severity: z.enum(['sign_up_requires_approval', 'sign_up_block', 'no_access']),
+  comment: z.string().catch(''),
+  created_at: dateSchema,
+  expires_at: z.string().datetime({ offset: true }),
+});
+
+type AdminIpBlock = z.infer<typeof adminIpBlockSchema>;
+
+export {
+  adminIpBlockSchema,
+  type AdminIpBlock,
+};

packages/pl-api/lib/entities/admin/ip.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+import { dateSchema } from '../utils';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_Ip/} */
+const adminIpSchema = z.object({
+  ip: z.string().ip(),
+  used_at: dateSchema,
+});
+
+type AdminIp = z.infer<typeof adminIpSchema>;
+
+export {
+  adminIpSchema,
+  type AdminIp,
+};

packages/pl-api/lib/entities/admin/measure.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_Measure/} */
+const adminMeasureSchema = z.object({
+  key: z.string(),
+  unit: z.string().nullable().catch(null),
+  total: z.coerce.number(),
+  human_value: z.string().optional().catch(undefined),
+  previous_total: z.coerce.string().optional().catch(undefined),
+  data: z.array(z.object({
+    date: z.string().datetime({ offset: true }),
+    value: z.coerce.string(),
+  })),
+});
+
+type AdminMeasure = z.infer<typeof adminMeasureSchema>;
+
+export {
+  adminMeasureSchema,
+  type AdminMeasure,
+};

packages/pl-api/lib/entities/admin/moderation-log-entry.ts

@@ -0,0 +1,13 @@
+import z from 'zod';
+
+/** @see {@link https://docs.pleroma.social/backend/development/API/admin_api/#get-apiv1pleromaadminmoderation_log} */
+const adminModerationLogEntrySchema = z.object({
+  id: z.coerce.string(),
+  data: z.record(z.string(), z.any()).catch({}),
+  time: z.number().catch(0),
+  message: z.string().catch(''),
+});
+
+type AdminModerationLogEntry = z.infer<typeof adminModerationLogEntrySchema>
+
+export { adminModerationLogEntrySchema, type AdminModerationLogEntry };

packages/pl-api/lib/entities/admin/relay.ts

@@ -0,0 +1,11 @@
+import z from 'zod';
+
+const adminRelaySchema = z.preprocess((data: any) => ({ id: data.actor, ...data }), z.object({
+  actor: z.string().catch(''),
+  id: z.string(),
+  followed_back: z.boolean().catch(false),
+}));
+
+type AdminRelay = z.infer<typeof adminRelaySchema>
+
+export { adminRelaySchema, type AdminRelay };

packages/pl-api/lib/entities/admin/report.ts

@@ -0,0 +1,46 @@
+import pick from 'lodash.pick';
+import { z } from 'zod';
+
+import { ruleSchema } from '../rule';
+import { statusWithoutAccountSchema } from '../status';
+import { dateSchema, filteredArray } from '../utils';
+
+import { adminAccountSchema } from './account';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Admin_Report/} */
+const adminReportSchema = z.preprocess((report: any) => {
+  if (report.actor) {
+    /**
+     * Convert Pleroma report schema
+     * @see {@link https://docs.pleroma.social/backend/development/API/admin_api/#get-apiv1pleromaadminreports}
+     */
+    return {
+      action_taken: report.state !== 'open',
+      comment: report.content,
+      updated_at: report.created_at,
+      account: report.actor,
+      target_account: report.account,
+      ...(pick(report, ['id', 'assigned_account', 'created_at', 'rules', 'statuses'])),
+    };
+  }
+  return report;
+}, z.object({
+  id: z.string(),
+  action_taken: z.boolean().optional().catch(undefined),
+  action_taken_at: dateSchema.nullable().catch(null),
+  category: z.string().optional().catch(undefined),
+  comment: z.string().optional().catch(undefined),
+  forwarded: z.boolean().optional().catch(undefined),
+  created_at: dateSchema.optional().catch(undefined),
+  updated_at: dateSchema.optional().catch(undefined),
+  account: adminAccountSchema,
+  target_account: adminAccountSchema,
+  assigned_account: adminAccountSchema.nullable().catch(null),
+  action_taken_by_account: adminAccountSchema.nullable().catch(null),
+  statuses: filteredArray(statusWithoutAccountSchema),
+  rules: filteredArray(ruleSchema),
+}));
+
+type AdminReport = z.infer<typeof adminReportSchema>;
+
+export { adminReportSchema, type AdminReport };

packages/pl-api/lib/entities/admin/rule.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+/** @see {@link https://docs.pleroma.social/backend/development/API/admin_api/#get-apiv1pleromaadminrules} */
+const adminRuleSchema = z.object({
+  id: z.string(),
+  text: z.string().catch(''),
+  hint: z.string().catch(''),
+  priority: z.number().nullable().catch(null),
+});
+
+type AdminRule = z.infer<typeof adminRuleSchema>;
+
+export { adminRuleSchema, type AdminRule };

packages/pl-api/lib/entities/admin/tag.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+import { tagSchema } from '../tag';
+
+/** @see {@link https://docs.joinmastodon.org/entities/Tag/#admin} */
+const adminTagSchema = tagSchema.extend({
+  id: z.string(),
+  trendable: z.boolean(),
+  usable: z.boolean(),
+  requires_review: z.boolean(),
+});
+
+type AdminTag = z.infer<typeof adminTagSchema>;
+
+export {
+  adminTagSchema,
+  type AdminTag,
+};