@abyss-project/link 0.0.0-stage → 1.1.0

package/src/index.ts

@@ -0,0 +1,180 @@
+import axios from 'axios';
+import axiosRetry, { IAxiosRetryConfig, isNetworkOrIdempotentRequestError } from 'axios-retry';
+
+export * from './api';
+export * from './types';
+export * from './utils';
+export * from './constants';
+
+import * as abyssAdminApi from './api/abyss.admin.api';
+import * as linkApi from './api/link.api';
+import * as linkAdminApi from './api/link.admin.api';
+import * as linkPublicApi from './api/link.public.api';
+
+const DEFAULT_BASE_URL = 'https://link-api.abyss-project.fr/api/';
+
+export const API_KEY_HEADER = 'abyss-api-key';
+export const ADMIN_TOKEN_HEADER = 'abyss-admin-token';
+
+const NUMBER_RETRY_API = 10;
+const BASE_DELAY_BETWEEN_RETRY = 5000;
+const RETRY_CODES = [
+  502, // Bad Gateway
+  503, // Service Unavailable
+];
+
+type CoreConfig = {
+  token?: string;
+  apiKey?: string;
+  adminToken?: string;
+  baseURL?: string;
+};
+
+type AbyssLinkCoreSDK = {
+  abyss: {
+    admin: {
+      activateUserService: typeof abyssAdminApi.activateUserServiceAbyssAdmin;
+      syncOrganization: typeof abyssAdminApi.syncOrganizationAbyssAdmin;
+      syncProject: typeof abyssAdminApi.syncProjectAbyssAdmin;
+    };
+  };
+  link: {
+    get: typeof linkApi.getLink;
+    paginate: typeof linkApi.paginateLink;
+    paginateProject: typeof linkApi.paginateProjectLink;
+    paginateOrganization: typeof linkApi.paginateOrganizationLink;
+    countOrganization: typeof linkApi.countOrganizationLink;
+    create: typeof linkApi.createLink;
+    createForOrganization: typeof linkApi.createForOrganizationLink;
+    update: typeof linkApi.updateLink;
+    delete: typeof linkApi.deleteLink;
+    transfer: typeof linkApi.transferLink;
+    getStats: typeof linkApi.getStatsLink;
+    getVisits: typeof linkApi.getVisitsLink;
+    getByOrigin: typeof linkApi.getByOriginLink;
+    getStatsByOrigin: typeof linkApi.getStatsByOriginLink;
+    public: {
+      unlock: typeof linkPublicApi.unlockLinkPublic;
+    };
+    admin: {
+      paginate: typeof linkAdminApi.paginateLinkAdmin;
+      get: typeof linkAdminApi.getLinkAdmin;
+      getVisits: typeof linkAdminApi.getVisitsLinkAdmin;
+      getCampaignStats: typeof linkAdminApi.getCampaignStatsLinkAdmin;
+      setProtection: typeof linkAdminApi.setProtectionLinkAdmin;
+      update: typeof linkAdminApi.updateLinkAdmin;
+      delete: typeof linkAdminApi.deleteLinkAdmin;
+      create: typeof linkAdminApi.createLinkAdmin;
+      getByOrigin: typeof linkAdminApi.getByOriginLinkAdmin;
+      getStatsByOrigin: typeof linkAdminApi.getStatsByOriginLinkAdmin;
+      recordCampaignView: typeof linkAdminApi.recordCampaignViewLinkAdmin;
+      listCampaignTokens: typeof linkAdminApi.listCampaignTokensLinkAdmin;
+      deleteCampaignToken: typeof linkAdminApi.deleteCampaignTokenLinkAdmin;
+    };
+  };
+};
+
+export class AbyssLinkCore {
+  private static config = {
+    token: '',
+    apiKey: '',
+    adminToken: '',
+    baseURL: DEFAULT_BASE_URL,
+  };
+  static axios = axios.create({
+    baseURL: this.config.baseURL,
+    withCredentials: true,
+  });
+
+  private static _sdk: AbyssLinkCoreSDK | null = null;
+
+  public static get sdk(): AbyssLinkCoreSDK {
+    if (!AbyssLinkCore._sdk) {
+      AbyssLinkCore._sdk = AbyssLinkCore.buildSDK();
+    }
+    return AbyssLinkCore._sdk;
+  }
+
+  private static buildSDK(): AbyssLinkCoreSDK {
+    return {
+      abyss: {
+        admin: {
+          activateUserService: abyssAdminApi.activateUserServiceAbyssAdmin,
+          syncOrganization: abyssAdminApi.syncOrganizationAbyssAdmin,
+          syncProject: abyssAdminApi.syncProjectAbyssAdmin,
+        },
+      },
+      link: {
+        get: linkApi.getLink,
+        paginate: linkApi.paginateLink,
+        paginateProject: linkApi.paginateProjectLink,
+        paginateOrganization: linkApi.paginateOrganizationLink,
+        countOrganization: linkApi.countOrganizationLink,
+        create: linkApi.createLink,
+        createForOrganization: linkApi.createForOrganizationLink,
+        update: linkApi.updateLink,
+        delete: linkApi.deleteLink,
+        transfer: linkApi.transferLink,
+        getStats: linkApi.getStatsLink,
+        getVisits: linkApi.getVisitsLink,
+        getByOrigin: linkApi.getByOriginLink,
+        getStatsByOrigin: linkApi.getStatsByOriginLink,
+        public: {
+          unlock: linkPublicApi.unlockLinkPublic,
+        },
+        admin: {
+          paginate: linkAdminApi.paginateLinkAdmin,
+          get: linkAdminApi.getLinkAdmin,
+          getVisits: linkAdminApi.getVisitsLinkAdmin,
+          getCampaignStats: linkAdminApi.getCampaignStatsLinkAdmin,
+          setProtection: linkAdminApi.setProtectionLinkAdmin,
+          update: linkAdminApi.updateLinkAdmin,
+          delete: linkAdminApi.deleteLinkAdmin,
+          create: linkAdminApi.createLinkAdmin,
+          getByOrigin: linkAdminApi.getByOriginLinkAdmin,
+          getStatsByOrigin: linkAdminApi.getStatsByOriginLinkAdmin,
+          recordCampaignView: linkAdminApi.recordCampaignViewLinkAdmin,
+          listCampaignTokens: linkAdminApi.listCampaignTokensLinkAdmin,
+          deleteCampaignToken: linkAdminApi.deleteCampaignTokenLinkAdmin,
+        },
+      },
+    };
+  }
+
+  public static enableAxiosRetry(axiosRetryConfig?: IAxiosRetryConfig): void {
+    axiosRetry(AbyssLinkCore.axios, {
+      retries: NUMBER_RETRY_API,
+      retryDelay: (retryCount) => retryCount * BASE_DELAY_BETWEEN_RETRY,
+      retryCondition: (error) =>
+        isNetworkOrIdempotentRequestError(error) ||
+        RETRY_CODES.includes(error.response?.status || 502),
+      ...axiosRetryConfig,
+    });
+  }
+
+  public static setConfig(config: CoreConfig): void {
+    AbyssLinkCore._sdk = null;
+
+    AbyssLinkCore.config = { ...AbyssLinkCore.config, ...config };
+
+    if (config.baseURL) {
+      AbyssLinkCore.axios.defaults.baseURL = config.baseURL;
+    }
+
+    if (config.token) {
+      AbyssLinkCore.axios.defaults.headers.common.Authorization = `Bearer ${config.token}`;
+    }
+
+    if (config.apiKey) {
+      AbyssLinkCore.axios.defaults.headers.common[API_KEY_HEADER] = `${config.apiKey}`;
+    }
+
+    if (config.adminToken) {
+      AbyssLinkCore.axios.defaults.headers.common[ADMIN_TOKEN_HEADER] = `${config.adminToken}`;
+    }
+  }
+
+  public static getConfig(): CoreConfig {
+    return AbyssLinkCore.config;
+  }
+}

package/src/tests/link-public-api.spec.ts

@@ -0,0 +1,37 @@
+import { AbyssLinkCore } from '..';
+
+describe('AbyssLinkCore.sdk.link.public', () => {
+  let post: jest.SpyInstance;
+
+  beforeEach(() => {
+    post = jest
+      .spyOn(AbyssLinkCore.axios, 'post')
+      .mockResolvedValue({ data: { data: { url: 'https://example.com/landing' } } });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('unlocks with POST link/public/<slug>/unlock, the password and the visit data in the body', async () => {
+    const answer = await AbyssLinkCore.sdk.link.public.unlock({
+      slug: 'Launch',
+      password: 'open sesame',
+      ref: 'https://news.example.org/a',
+      utmSource: 'mail',
+    });
+
+    expect(post).toHaveBeenCalledWith('link/public/Launch/unlock', {
+      password: 'open sesame',
+      ref: 'https://news.example.org/a',
+      utmSource: 'mail',
+    });
+    expect(answer).toEqual({ data: { url: 'https://example.com/landing' } });
+  });
+
+  it('encodes the slug in the path', async () => {
+    await AbyssLinkCore.sdk.link.public.unlock({ slug: 'a/b', password: 'x' });
+
+    expect(post).toHaveBeenCalledWith('link/public/a%2Fb/unlock', { password: 'x' });
+  });
+});

package/src/tests/link-sdk-surface.spec.ts

@@ -0,0 +1,191 @@
+import { AbyssLinkCore, LinkKind, LinkResourceProduct, LinkStatsGranularity } from '..';
+
+const LINK_ID = '11111111-1111-4111-8111-111111111111';
+const ORGANIZATION_ID = '22222222-2222-4222-8222-222222222222';
+const PROJECT_ID = '33333333-3333-4333-8333-333333333333';
+const ORIGIN = {
+  service: LinkResourceProduct.BEAM,
+  resourceType: 'beam_transfer',
+  resourceId: '44444444-4444-4444-8444-444444444444',
+};
+
+/**
+ * `sdk.link.*` (the user routes of the Links screen) and `sdk.link.admin.*` (the back-office and
+ * Monitor): each call hits the route `link.controller.ts` / `link.admin.controller.ts` serve.
+ */
+describe('AbyssLinkCore sdk.link surface', () => {
+  let get: jest.SpyInstance;
+  let post: jest.SpyInstance;
+  let put: jest.SpyInstance;
+  let del: jest.SpyInstance;
+
+  beforeEach(() => {
+    const ok = { data: { data: {} } };
+    get = jest.spyOn(AbyssLinkCore.axios, 'get').mockResolvedValue(ok);
+    post = jest.spyOn(AbyssLinkCore.axios, 'post').mockResolvedValue(ok);
+    put = jest.spyOn(AbyssLinkCore.axios, 'put').mockResolvedValue(ok);
+    del = jest.spyOn(AbyssLinkCore.axios, 'delete').mockResolvedValue(ok);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('exposes the user routes and the admin routes', () => {
+    expect(Object.keys(AbyssLinkCore.sdk.link)).toEqual(
+      expect.arrayContaining([
+        'get',
+        'paginate',
+        'paginateProject',
+        'paginateOrganization',
+        'countOrganization',
+        'create',
+        'createForOrganization',
+        'update',
+        'delete',
+        'transfer',
+        'getStats',
+        'getVisits',
+        'getByOrigin',
+        'getStatsByOrigin',
+        'admin',
+      ]),
+    );
+    expect(Object.keys(AbyssLinkCore.sdk.link.admin).sort()).toEqual([
+      'create',
+      'delete',
+      'deleteCampaignToken',
+      'get',
+      'getByOrigin',
+      'getCampaignStats',
+      'getStatsByOrigin',
+      'getVisits',
+      'listCampaignTokens',
+      'paginate',
+      'recordCampaignView',
+      'setProtection',
+      'update',
+    ]);
+  });
+
+  it('reads the user routes', async () => {
+    const { link } = AbyssLinkCore.sdk;
+    await link.get({ linkId: LINK_ID });
+    expect(get).toHaveBeenLastCalledWith(`link/${LINK_ID}`);
+    await link.paginate({ page: 2, search: 'promo' });
+    expect(get).toHaveBeenLastCalledWith('link/paginate', { params: { page: 2, search: 'promo' } });
+    await link.paginateProject({ projectId: PROJECT_ID }, { page: 1 });
+    expect(get).toHaveBeenLastCalledWith(`link/project/${PROJECT_ID}/paginate`, {
+      params: { page: 1 },
+    });
+    await link.paginateOrganization({ organizationId: ORGANIZATION_ID }, { adminView: true });
+    expect(get).toHaveBeenLastCalledWith(`link/organization/${ORGANIZATION_ID}/paginate`, {
+      params: { adminView: true },
+    });
+    await link.countOrganization({ organizationId: ORGANIZATION_ID });
+    expect(get).toHaveBeenLastCalledWith(`link/organization/${ORGANIZATION_ID}/count`, {
+      params: {},
+    });
+    await link.getStats({ linkId: LINK_ID }, { granularity: LinkStatsGranularity.WEEK });
+    expect(get).toHaveBeenLastCalledWith(`link/${LINK_ID}/stats`, {
+      params: { granularity: LinkStatsGranularity.WEEK },
+    });
+    await link.getVisits({ linkId: LINK_ID }, { page: 3 });
+    expect(get).toHaveBeenLastCalledWith(`link/${LINK_ID}/visits`, { params: { page: 3 } });
+    await link.getByOrigin(ORIGIN);
+    expect(get).toHaveBeenLastCalledWith('link/origin', { params: ORIGIN });
+    await link.getStatsByOrigin({ ...ORIGIN, from: '2026-11-01' });
+    expect(get).toHaveBeenLastCalledWith('link/origin/stats', {
+      params: { ...ORIGIN, from: '2026-11-01' },
+    });
+  });
+
+  it('writes through the user routes', async () => {
+    const { link } = AbyssLinkCore.sdk;
+    await link.create({ targetUrl: 'https://example.com' });
+    expect(post).toHaveBeenLastCalledWith('link', { targetUrl: 'https://example.com' });
+    await link.createForOrganization(
+      { organizationId: ORGANIZATION_ID },
+      { targetUrl: 'https://example.com', projectId: PROJECT_ID },
+    );
+    expect(post).toHaveBeenLastCalledWith(`link/organization/${ORGANIZATION_ID}`, {
+      targetUrl: 'https://example.com',
+      projectId: PROJECT_ID,
+    });
+    await link.update({ linkId: LINK_ID }, { isActive: false });
+    expect(put).toHaveBeenLastCalledWith(`link/${LINK_ID}`, { isActive: false });
+    await link.transfer({ linkId: LINK_ID }, { newOwnerId: PROJECT_ID });
+    expect(post).toHaveBeenLastCalledWith(`link/${LINK_ID}/transfer`, { newOwnerId: PROJECT_ID });
+    await link.delete({ linkId: LINK_ID });
+    expect(del).toHaveBeenLastCalledWith(`link/${LINK_ID}`);
+  });
+
+  it('calls the admin routes', async () => {
+    const { admin } = AbyssLinkCore.sdk.link;
+    await admin.paginate({ isProtected: true });
+    expect(get).toHaveBeenLastCalledWith('admin/link/paginate', {
+      params: { isProtected: true },
+    });
+    await admin.get({ linkId: LINK_ID });
+    expect(get).toHaveBeenLastCalledWith(`admin/link/${LINK_ID}`);
+    await admin.getVisits({ linkId: LINK_ID }, { limit: 10 });
+    expect(get).toHaveBeenLastCalledWith(`admin/link/${LINK_ID}/visits`, {
+      params: { limit: 10 },
+    });
+    await admin.getCampaignStats(
+      { linkId: LINK_ID },
+      { from: '2026-11-01T00:00:00.000Z', to: '2026-11-11T00:00:00.000Z' },
+    );
+    expect(get).toHaveBeenLastCalledWith(`admin/link/${LINK_ID}/campaign-stats`, {
+      params: { from: '2026-11-01T00:00:00.000Z', to: '2026-11-11T00:00:00.000Z' },
+    });
+    await admin.setProtection({ linkId: LINK_ID }, { isProtected: true, adminId: PROJECT_ID });
+    expect(put).toHaveBeenLastCalledWith(`admin/link/${LINK_ID}/protection`, {
+      isProtected: true,
+      adminId: PROJECT_ID,
+    });
+    await admin.update({ linkId: LINK_ID }, { isActive: false });
+    expect(put).toHaveBeenLastCalledWith(`admin/link/${LINK_ID}`, { isActive: false });
+    await admin.delete({ linkId: LINK_ID });
+    expect(del).toHaveBeenLastCalledWith(`admin/link/${LINK_ID}`);
+  });
+
+  it('calls the product routes (T3.1)', async () => {
+    const { admin } = AbyssLinkCore.sdk.link;
+    const scope = { userId: null, organizationId: ORGANIZATION_ID, projectId: PROJECT_ID };
+    await admin.create({
+      kind: LinkKind.RESOURCE,
+      origin: ORIGIN,
+      targetUrl: 'https://beam.example.com/b/x',
+      scope,
+    });
+    expect(post).toHaveBeenLastCalledWith('admin/link', {
+      kind: LinkKind.RESOURCE,
+      origin: ORIGIN,
+      targetUrl: 'https://beam.example.com/b/x',
+      scope,
+    });
+    await admin.getByOrigin(ORIGIN);
+    expect(get).toHaveBeenLastCalledWith('admin/link/origin', { params: ORIGIN });
+    await admin.getStatsByOrigin(ORIGIN, { granularity: LinkStatsGranularity.MONTH });
+    expect(get).toHaveBeenLastCalledWith('admin/link/origin/stats', {
+      params: { ...ORIGIN, granularity: LinkStatsGranularity.MONTH },
+    });
+    await admin.getStatsByOrigin(ORIGIN);
+    expect(get).toHaveBeenLastCalledWith('admin/link/origin/stats', { params: ORIGIN });
+    const view = { token: 'Ab3dE5gH9kLm', ip: '203.0.113.7', utm: { utmSource: 'mail' } };
+    await admin.recordCampaignView(view);
+    expect(post).toHaveBeenLastCalledWith('admin/link/campaign-view', view);
+    await admin.listCampaignTokens(ORIGIN);
+    expect(get).toHaveBeenLastCalledWith('admin/link/campaign-token', { params: ORIGIN });
+    await admin.deleteCampaignToken({ linkId: LINK_ID });
+    expect(del).toHaveBeenLastCalledWith(`admin/link/campaign-token/${LINK_ID}`);
+  });
+
+  it('returns the response body', async () => {
+    get.mockResolvedValueOnce({ data: { data: { link: { id: LINK_ID } } } });
+    await expect(AbyssLinkCore.sdk.link.get({ linkId: LINK_ID })).resolves.toEqual({
+      data: { link: { id: LINK_ID } },
+    });
+  });
+});

package/src/tests/sdk-surface.spec.ts

@@ -0,0 +1,63 @@
+import { AbyssLinkCore, ADMIN_TOKEN_HEADER } from '..';
+
+const USER_ID = '11111111-1111-4111-8111-111111111111';
+const ORGANIZATION_ID = '22222222-2222-4222-8222-222222222222';
+const PROJECT_ID = '33333333-3333-4333-8333-333333333333';
+
+describe('AbyssLinkCore SDK surface', () => {
+  let post: jest.SpyInstance;
+
+  beforeEach(() => {
+    post = jest.spyOn(AbyssLinkCore.axios, 'post').mockResolvedValue({ data: { data: {} } });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('exposes exactly the three abyss.admin calls', () => {
+    expect(Object.keys(AbyssLinkCore.sdk)).toEqual(['abyss', 'link']);
+    expect(Object.keys(AbyssLinkCore.sdk.abyss)).toEqual(['admin']);
+    expect(Object.keys(AbyssLinkCore.sdk.abyss.admin).sort()).toEqual([
+      'activateUserService',
+      'syncOrganization',
+      'syncProject',
+    ]);
+  });
+
+  it('activates a user with POST abyss/admin/user/activate-service', async () => {
+    const body = { userId: USER_ID };
+    await AbyssLinkCore.sdk.abyss.admin.activateUserService(body);
+    expect(post).toHaveBeenCalledWith('abyss/admin/user/activate-service', body);
+  });
+
+  it('syncs an organization with POST abyss/admin/organization/sync', async () => {
+    const body = { id: ORGANIZATION_ID, name: 'Org', slug: 'org' };
+    await AbyssLinkCore.sdk.abyss.admin.syncOrganization(body);
+    expect(post).toHaveBeenCalledWith('abyss/admin/organization/sync', body);
+  });
+
+  it('syncs a project with POST abyss/admin/project/sync', async () => {
+    const body = {
+      id: PROJECT_ID,
+      name: 'Project',
+      createdByUserId: null,
+      organizationId: ORGANIZATION_ID,
+    };
+    await AbyssLinkCore.sdk.abyss.admin.syncProject(body);
+    expect(post).toHaveBeenCalledWith('abyss/admin/project/sync', body);
+  });
+
+  it('returns the response body', async () => {
+    post.mockResolvedValueOnce({ data: { data: { user: { id: USER_ID, isAdmin: false } } } });
+    await expect(
+      AbyssLinkCore.sdk.abyss.admin.activateUserService({ userId: USER_ID }),
+    ).resolves.toEqual({ data: { user: { id: USER_ID, isAdmin: false } } });
+  });
+
+  it('sends the admin token and the base URL given to setConfig', () => {
+    AbyssLinkCore.setConfig({ adminToken: 'admin-token', baseURL: 'http://localhost:10144/api/' });
+    expect(AbyssLinkCore.axios.defaults.headers.common[ADMIN_TOKEN_HEADER]).toBe('admin-token');
+    expect(AbyssLinkCore.axios.defaults.baseURL).toBe('http://localhost:10144/api/');
+  });
+});

package/src/types/enum/api-error.enum.ts

@@ -0,0 +1,31 @@
+export enum ErrorType {
+  apiError = 'api_error',
+  authError = 'authentication_error',
+  resourceError = 'resource_error',
+}
+
+export enum Code {
+  // HTTP Error
+  tokenFailure = 'token_authentication_failure',
+  authenticationFailure = 'authentication_credentials_failure',
+  accessNotAllowed = 'access_not_allowed',
+  notFound = 'not_found',
+  validationError = 'resource_validation_error',
+  constraintError = 'resource_constraint_error',
+  internalServerError = 'internal_server_error',
+  serviceUnavailable = 'service_unavailable',
+  invalidData = 'invalid_data',
+
+  // Link management (422 / 409 / 403 with an explicit code the front can name)
+  linkSlugForbidden = 'link_slug_forbidden',
+  linkTargetForbidden = 'link_target_forbidden',
+  linkSlugTaken = 'link_slug_taken',
+  linkProtected = 'link_protected',
+  linkManagedByProduct = 'link_managed_by_product',
+  // 422: the product resource already holds LINK_CAMPAIGN_TOKENS_PER_PROJECT campaign tokens (O5)
+  linkCampaignTokenLimit = 'link_campaign_token_limit',
+
+  // Link unlock (401 wrong password, 410 a link that can no longer be followed)
+  linkWrongPassword = 'link_wrong_password',
+  linkExpired = 'link_expired',
+}

package/src/types/enum/index.ts

@@ -0,0 +1,4 @@
+export * from './api-error.enum';
+export * from './link.enum';
+export * from './link-stats.enum';
+export * from './link-share.enum';

package/src/types/enum/link-share.enum.ts

@@ -0,0 +1,17 @@
+/**
+ * Permission of the caller on a link, from abyss-main's content sharing (spec §5). Same values as
+ * `SharePermission` of `@abyss-project/main`, which this SDK does not depend on.
+ */
+export enum LinkSharePermission {
+  VIEW = 'VIEW',
+  EDIT = 'EDIT',
+  MANAGE = 'MANAGE',
+}
+
+/** Scope of the organization list, same values as `ContentShareScope` of `@abyss-project/main`. */
+export enum LinkShareScope {
+  ORGANIZATION = 'ORGANIZATION',
+  ORG_USER = 'ORG_USER',
+  ORG_TEAM = 'ORG_TEAM',
+  ORG_PROJECT = 'ORG_PROJECT',
+}

package/src/types/enum/link-stats.enum.ts

@@ -0,0 +1,6 @@
+/** Bucket of the series of `getStats`. A bucket sums the daily values of its UTC days. */
+export enum LinkStatsGranularity {
+  DAY = 'DAY',
+  WEEK = 'WEEK',
+  MONTH = 'MONTH',
+}

package/src/types/enum/link.enum.ts

@@ -0,0 +1,34 @@
+/** The three sorts of link (spec §2). Stored as is in `links.kind`. */
+export enum LinkKind {
+  /** Owned by a user, served by Link at `<host>/<slug>`, billed on ABYSS_LINK. */
+  SHORTENED = 'SHORTENED',
+  /** Owned by a product, served by Link at `<host>/<prefix>/<code>`, never listed, never billed. */
+  RESOURCE = 'RESOURCE',
+  /** Owned by a user, no Link address: a token the target product (Spotlight) reads from its query string. */
+  CAMPAIGN_TOKEN = 'CAMPAIGN_TOKEN',
+}
+
+/** Where a visit was recorded. Stored as is in `link_visits.source`. */
+export enum LinkVisitSource {
+  /** A 302 served by the Link host. */
+  REDIRECT = 'REDIRECT',
+  /** A page view a product reported for a campaign token. */
+  CAMPAIGN_VIEW = 'CAMPAIGN_VIEW',
+}
+
+/**
+ * The product a RESOURCE or CAMPAIGN_TOKEN link belongs to (`links.originService`).
+ * Link's own list, not main's `AbyssService`: a Link product is not a billing service, and
+ * Atlas, Draw and Retrospective are tools of AbyssWorkspace, not services.
+ */
+export enum LinkResourceProduct {
+  BEAM = 'BEAM',
+  SPOTLIGHT = 'SPOTLIGHT',
+  ATLAS = 'ATLAS',
+  DRAW = 'DRAW',
+  RETROSPECTIVE = 'RETROSPECTIVE',
+  FORM = 'FORM',
+  EXTRACT = 'EXTRACT',
+  CLOUD = 'CLOUD',
+  MEMORIES = 'MEMORIES',
+}

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './enum';

package/src/types/interface/api/index.ts

@@ -0,0 +1,5 @@
+export * from './requests';
+export * from './responses';
+export * from './type-message/response';
+export * from './type-message/api-error';
+export * from './type-message/base-paginate';

package/src/types/interface/api/requests/abyss.admin.request.ts

@@ -0,0 +1,17 @@
+export interface IActivateUserServiceAbyssAdminBody {
+  userId: string;
+}
+
+export interface ISyncOrganizationAbyssAdminBody {
+  id: string;
+  name: string;
+  slug: string;
+}
+
+export interface ISyncProjectAbyssAdminBody {
+  id: string;
+  name: string;
+  /** null when the author's account was deleted: the project outlives it (#199). */
+  createdByUserId: string | null;
+  organizationId: string;
+}

package/src/types/interface/api/requests/index.ts

@@ -0,0 +1,4 @@
+export * from './abyss.admin.request';
+export * from './link.request';
+export * from './link.admin.request';
+export * from './link.public.request';