@rynt/sdk 0.9.53

package/src/extension-marketplace/client.ts

@@ -0,0 +1,296 @@
+import type {
+  ApproveSubmissionRequest,
+  CreateSubmissionRequest,
+  DeveloperPublishedExtension,
+  ExtensionArtifactUploadResult,
+  ExtensionSubmission,
+  MarketplaceApiError,
+  MarketplaceExtensionDetail,
+  MarketplaceSearchQuery,
+  MarketplaceSearchResponse,
+  MarketplaceSlotLookupResult,
+  MarketplaceSlotQuery,
+  PublishExtensionResponse,
+  RejectSubmissionRequest,
+  SubmissionStatus,
+  UpdateExtensionListingRequest,
+  ExtensionListingMeta,
+} from './api-types';
+import { marketplaceSlotLookupResultSchema } from './schemas';
+
+export interface ExtensionMarketplaceClientOptions {
+  baseUrl: string;
+  getAuthToken?: () => string | Promise<string | null>;
+  fetchImpl?: typeof fetch;
+}
+
+async function readApiError(res: Response): Promise<MarketplaceApiError> {
+  try {
+    const body = (await res.json()) as MarketplaceApiError;
+    if (body?.code && body?.message) {
+      return body;
+    }
+  } catch {
+    /* ignore */
+  }
+  return {
+    code: 'VALIDATION_ERROR',
+    message: res.statusText || `HTTP ${res.status}`,
+  };
+}
+
+async function requestJson<T>(
+  fetchFn: typeof fetch,
+  url: string,
+  init: RequestInit,
+): Promise<T> {
+  const res = await fetchFn(url, init);
+  if (!res.ok) {
+    throw await readApiError(res);
+  }
+  if (res.status === 204) {
+    return undefined as T;
+  }
+  return (await res.json()) as T;
+}
+
+export interface ExtensionMarketplaceClient {
+  lookupSlot(query: MarketplaceSlotQuery): Promise<MarketplaceSlotLookupResult>;
+  getExtension(id: string, version?: string): Promise<MarketplaceExtensionDetail>;
+  search(query: MarketplaceSearchQuery): Promise<MarketplaceSearchResponse>;
+
+  uploadArtifact(file: File): Promise<ExtensionArtifactUploadResult>;
+  listMyPublishedExtensions(): Promise<DeveloperPublishedExtension[]>;
+  getMyPublishedExtension(extensionId: string): Promise<DeveloperPublishedExtension>;
+  listMySubmissions(status?: SubmissionStatus): Promise<ExtensionSubmission[]>;
+  getMySubmission(id: string): Promise<ExtensionSubmission>;
+  createSubmission(body: CreateSubmissionRequest): Promise<ExtensionSubmission>;
+  submitForReview(id: string): Promise<ExtensionSubmission>;
+  deleteSubmission(id: string): Promise<void>;
+
+  updateSubmissionListing(
+    id: string,
+    body: UpdateExtensionListingRequest,
+  ): Promise<ExtensionSubmission>;
+  updatePublishedExtensionListing(
+    extensionId: string,
+    body: UpdateExtensionListingRequest,
+  ): Promise<ExtensionListingMeta & { id: string; version: string }>;
+
+  listPendingSubmissions(options?: {
+    status?: SubmissionStatus;
+    limit?: number;
+    offset?: number;
+  }): Promise<{ items: ExtensionSubmission[]; total: number }>;
+  getAdminSubmission(id: string): Promise<ExtensionSubmission>;
+  approveSubmission(
+    id: string,
+    body?: ApproveSubmissionRequest,
+  ): Promise<PublishExtensionResponse>;
+  rejectSubmission(
+    id: string,
+    body?: RejectSubmissionRequest,
+  ): Promise<ExtensionSubmission>;
+}
+
+export function createExtensionMarketplaceClient(
+  options: ExtensionMarketplaceClientOptions,
+): ExtensionMarketplaceClient {
+  const base = options.baseUrl.replace(/\/+$/u, '');
+  const fetchFn = options.fetchImpl ?? fetch;
+
+  async function authHeaders(json = false): Promise<HeadersInit> {
+    const h: Record<string, string> = {
+      Accept: 'application/json',
+    };
+    if (json) {
+      h['Content-Type'] = 'application/json';
+    }
+    if (options.getAuthToken) {
+      const token = await options.getAuthToken();
+      if (token) {
+        h.Authorization = `Bearer ${token}`;
+      }
+    }
+    return h;
+  }
+
+  return {
+    async lookupSlot(query) {
+      const params = new URLSearchParams({
+        registryId: query.registryId,
+        key: query.key,
+      });
+      const raw = await requestJson<unknown>(
+        fetchFn,
+        `${base}/api/v1/extensions/slots?${params}`,
+        { headers: await authHeaders() },
+      );
+      const parsed = marketplaceSlotLookupResultSchema.safeParse(raw);
+      if (!parsed.success) {
+        throw {
+          code: 'VALIDATION_ERROR',
+          message: parsed.error.message,
+        } satisfies MarketplaceApiError;
+      }
+      return parsed.data as MarketplaceSlotLookupResult;
+    },
+
+    async getExtension(id, version) {
+      const path = version
+        ? `${base}/api/v1/extensions/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}`
+        : `${base}/api/v1/extensions/${encodeURIComponent(id)}`;
+      return requestJson(fetchFn, path, { headers: await authHeaders() });
+    },
+
+    async search(query) {
+      const params = new URLSearchParams();
+      if (query.q) params.set('q', query.q);
+      if (query.registryId) params.set('registryId', query.registryId);
+      if (query.limit != null) params.set('limit', String(query.limit));
+      if (query.offset != null) params.set('offset', String(query.offset));
+      const qs = params.toString();
+      return requestJson(
+        fetchFn,
+        `${base}/api/v1/extensions/search${qs ? `?${qs}` : ''}`,
+        { headers: await authHeaders() },
+      );
+    },
+
+    async listMyPublishedExtensions() {
+      const res = await requestJson<{ items: DeveloperPublishedExtension[] }>(
+        fetchFn,
+        `${base}/api/v1/developer/published-extensions`,
+        { headers: await authHeaders() },
+      );
+      return res.items;
+    },
+
+    async getMyPublishedExtension(extensionId) {
+      return requestJson(
+        fetchFn,
+        `${base}/api/v1/developer/published-extensions/${encodeURIComponent(extensionId)}`,
+        { headers: await authHeaders() },
+      );
+    },
+
+    async uploadArtifact(file) {
+      const form = new FormData();
+      form.append('file', file);
+      return requestJson(fetchFn, `${base}/api/v1/developer/artifacts`, {
+        method: 'POST',
+        headers: await authHeaders(),
+        body: form,
+      });
+    },
+
+    async listMySubmissions(status) {
+      const params = status ? `?status=${encodeURIComponent(status)}` : '';
+      const res = await requestJson<{ items: ExtensionSubmission[] }>(
+        fetchFn,
+        `${base}/api/v1/developer/submissions${params}`,
+        { headers: await authHeaders() },
+      );
+      return res.items;
+    },
+
+    async getMySubmission(id) {
+      return requestJson(fetchFn, `${base}/api/v1/developer/submissions/${encodeURIComponent(id)}`, {
+        headers: await authHeaders(),
+      });
+    },
+
+    async createSubmission(body) {
+      return requestJson(fetchFn, `${base}/api/v1/developer/submissions`, {
+        method: 'POST',
+        headers: await authHeaders(true),
+        body: JSON.stringify(body),
+      });
+    },
+
+    async submitForReview(id) {
+      return requestJson(
+        fetchFn,
+        `${base}/api/v1/developer/submissions/${encodeURIComponent(id)}/submit`,
+        { method: 'POST', headers: await authHeaders() },
+      );
+    },
+
+    async deleteSubmission(id) {
+      await requestJson(
+        fetchFn,
+        `${base}/api/v1/developer/submissions/${encodeURIComponent(id)}`,
+        { method: 'DELETE', headers: await authHeaders() },
+      );
+    },
+
+    async updateSubmissionListing(id, body) {
+      return requestJson(
+        fetchFn,
+        `${base}/api/v1/developer/submissions/${encodeURIComponent(id)}/listing`,
+        {
+          method: 'PATCH',
+          headers: await authHeaders(true),
+          body: JSON.stringify(body),
+        },
+      );
+    },
+
+    async updatePublishedExtensionListing(extensionId, body) {
+      return requestJson(
+        fetchFn,
+        `${base}/api/v1/developer/published-extensions/${encodeURIComponent(extensionId)}/listing`,
+        {
+          method: 'PATCH',
+          headers: await authHeaders(true),
+          body: JSON.stringify(body),
+        },
+      );
+    },
+
+    async listPendingSubmissions(opts) {
+      const params = new URLSearchParams();
+      if (opts?.status) params.set('status', opts.status);
+      if (opts?.limit != null) params.set('limit', String(opts.limit));
+      if (opts?.offset != null) params.set('offset', String(opts.offset));
+      const qs = params.toString();
+      return requestJson(
+        fetchFn,
+        `${base}/api/v1/admin/submissions${qs ? `?${qs}` : ''}`,
+        { headers: await authHeaders() },
+      );
+    },
+
+    async getAdminSubmission(id) {
+      return requestJson(
+        fetchFn,
+        `${base}/api/v1/admin/submissions/${encodeURIComponent(id)}`,
+        { headers: await authHeaders() },
+      );
+    },
+
+    async approveSubmission(id, body) {
+      return requestJson(
+        fetchFn,
+        `${base}/api/v1/admin/submissions/${encodeURIComponent(id)}/approve`,
+        {
+          method: 'POST',
+          headers: await authHeaders(true),
+          body: JSON.stringify(body ?? {}),
+        },
+      );
+    },
+
+    async rejectSubmission(id, body) {
+      return requestJson(
+        fetchFn,
+        `${base}/api/v1/admin/submissions/${encodeURIComponent(id)}/reject`,
+        {
+          method: 'POST',
+          headers: await authHeaders(true),
+          body: JSON.stringify(body ?? {}),
+        },
+      );
+    },
+  };
+}

package/src/extension-marketplace/index.ts

@@ -0,0 +1,22 @@
+export type * from './api-types.js';
+export {
+  approveSubmissionRequestSchema,
+  createSubmissionRequestSchema,
+  marketplaceManifestContributesRyntSchema,
+  marketplaceSearchQuerySchema,
+  marketplaceSlotQuerySchema,
+  MARKETPLACE_MAX_EXTENSION_API,
+  publishExtensionRequestSchema,
+  rejectSubmissionRequestSchema,
+  submissionStatusSchema,
+  updateExtensionListingRequestSchema,
+  validateManifestForMarketplacePublish,
+  validateSubmissionManifest,
+  type ValidateSubmissionManifestOptions,
+} from './schemas.js';
+export {
+  createExtensionMarketplaceClient,
+  type ExtensionMarketplaceClient,
+  type ExtensionMarketplaceClientOptions,
+} from './client.js';
+export { isValidSemver, isVersionGreater } from '../shared/utils/semver.js';

package/src/extension-marketplace/schemas.ts

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+
+import { parseExtensionApiMajor } from '../extensions/version';
+import { isValidSemver, isVersionGreater } from '../shared/utils/semver';
+
+const registryDeclSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().optional(),
+  description: z.string().optional(),
+});
+
+const registryExtendSchema = z.object({
+  registryId: z.string().min(1),
+  keys: z.array(z.string().min(1)).min(1),
+});
+
+export const marketplaceManifestContributesRyntSchema = z
+  .object({
+    declaresRegistries: z.array(registryDeclSchema).optional(),
+    extendsRegistries: z.array(registryExtendSchema).optional(),
+  })
+  .strict();
+
+export const submissionStatusSchema = z.enum([
+  'draft',
+  'pending',
+  'approved',
+  'rejected',
+]);
+
+/** Принимает объект или JSON-строку (legacy / ошибочный клиент). */
+export const marketplaceManifestRecordSchema = z.preprocess((val) => {
+  if (typeof val !== 'string') return val;
+  try {
+    const parsed: unknown = JSON.parse(val);
+    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    /* keep string — z.record ниже отклонит */
+  }
+  return val;
+}, z.record(z.unknown()));
+
+export const createSubmissionRequestSchema = z.object({
+  artifactId: z.string().uuid(),
+  manifest: marketplaceManifestRecordSchema,
+});
+
+export const rejectSubmissionRequestSchema = z.object({
+  reason: z.string().optional(),
+  reviewNote: z.string().optional(),
+});
+
+export const approveSubmissionRequestSchema = z.object({
+  reviewNote: z.string().optional(),
+});
+
+export const publishExtensionRequestSchema = z.object({
+  manifest: z.record(z.unknown()),
+  downloadUrl: z.string().url(),
+  artifactSha256: z.string().optional(),
+});
+
+export const marketplaceSlotQuerySchema = z.object({
+  registryId: z.string().min(1),
+  key: z.string().min(1),
+});
+
+export const marketplaceExtensionSummarySchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  version: z.string().min(1),
+  description: z.string().optional(),
+  iconUrl: z.string().optional(),
+  authorName: z.string().optional(),
+  downloadUrl: z.string().url(),
+  artifactSha256: z.string().optional(),
+});
+
+export const updateExtensionListingRequestSchema = z.object({
+  listingDescriptionHtml: z.string().optional(),
+});
+
+export const marketplaceSlotLookupResultSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('none') }),
+  z.object({
+    kind: z.literal('one'),
+    extension: marketplaceExtensionSummarySchema,
+  }),
+  z.object({
+    kind: z.literal('many'),
+    extensions: z.array(marketplaceExtensionSummarySchema).min(2),
+  }),
+]);
+
+export const marketplaceSearchQuerySchema = z.object({
+  q: z.string().optional(),
+  registryId: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional(),
+  offset: z.coerce.number().int().min(0).optional(),
+});
+
+/** Максимальная Extension API, которую принимает каталог при публикации. */
+export const MARKETPLACE_MAX_EXTENSION_API = 1;
+
+export function validateManifestForMarketplacePublish(
+  manifest: Record<string, unknown>,
+): { ok: true } | { ok: false; error: string } {
+  const id = manifest.id;
+  if (typeof id !== 'string' || !id.trim()) {
+    return { ok: false, error: 'manifest.id обязателен' };
+  }
+  const version = manifest.version;
+  if (typeof version !== 'string' || !version.trim()) {
+    return { ok: false, error: 'manifest.version обязателен' };
+  }
+  const apiMajor = parseExtensionApiMajor(manifest.extensionApi);
+  if (apiMajor === null) {
+    return { ok: false, error: 'extensionApi обязателен (например "1")' };
+  }
+  if (apiMajor > MARKETPLACE_MAX_EXTENSION_API) {
+    return {
+      ok: false,
+      error: `extensionApi ${apiMajor} не поддерживается каталогом (max ${MARKETPLACE_MAX_EXTENSION_API})`,
+    };
+  }
+  const raw = (manifest.contributes as Record<string, unknown> | undefined)?.rynt;
+  if (raw !== undefined) {
+    const parsed = marketplaceManifestContributesRyntSchema.safeParse(raw);
+    if (!parsed.success) {
+      return {
+        ok: false,
+        error: parsed.error.issues.map((i) => i.message).join('; '),
+      };
+    }
+  }
+  return { ok: true };
+}
+
+export interface ValidateSubmissionManifestOptions {
+  /** Последняя опубликованная версия (если обновление). */
+  latestPublishedVersion?: string;
+}
+
+/**
+ * Клиентская проверка перед загрузкой архива (сервер повторяет при сохранении заявки).
+ */
+export function validateSubmissionManifest(
+  manifest: Record<string, unknown>,
+  options?: ValidateSubmissionManifestOptions,
+): { ok: true } | { ok: false; error: string } {
+  const base = validateManifestForMarketplacePublish(manifest);
+  if (!base.ok) return base;
+
+  const version = String(manifest.version);
+  if (!isValidSemver(version)) {
+    return {
+      ok: false,
+      error: `manifest.version «${version}» — не semver (ожидается MAJOR.MINOR.PATCH)`,
+    };
+  }
+
+  const latest = options?.latestPublishedVersion?.trim();
+  if (latest) {
+    if (!isValidSemver(latest)) {
+      return { ok: false, error: 'Некорректная версия в каталоге' };
+    }
+    if (!isVersionGreater(version, latest)) {
+      return {
+        ok: false,
+        error: `Версия ${version} должна быть выше опубликованной ${latest}`,
+      };
+    }
+  }
+
+  return { ok: true };
+}

package/src/extensions/ExtensionRoutePage.vue

@@ -0,0 +1,17 @@
+<script setup lang="ts">
+  import { computed } from 'vue';
+  import type { Component } from 'vue';
+
+  const props = defineProps<{
+    pageComponent: Component;
+    extensionId: string;
+    registryKey: string;
+  }>();
+
+  /** Стабильный ключ: remount страницы — через suspend RouterView, не через смену import. */
+  const viewKey = computed(() => `${props.extensionId}:${props.registryKey}`);
+</script>
+
+<template>
+  <component :is="pageComponent" :key="viewKey" />
+</template>

package/src/extensions/context.ts

@@ -0,0 +1,37 @@
+import type {
+  RyntExtensionContext,
+  RyntExtensionHostApis,
+} from './plugin-types';
+import { setExtensionExpose } from './extension-expose';
+import { getExtensionRegistry } from './registries/define-extension-registry';
+import { withExtensionScope } from './registries/extension-scope';
+
+export function createRyntExtensionContext(
+  extensionId: string,
+  hostApis?: RyntExtensionHostApis,
+): RyntExtensionContext {
+  return {
+    extensionId,
+    hostApis,
+    registerRegistryEntry<T>(entry: {
+      registryId: string;
+      key: string;
+      value: T;
+      order?: number;
+    }) {
+      console.info(
+        `[rynt/extensions] registry «${entry.registryId}» / «${entry.key}» ← «${extensionId}»`,
+      );
+      withExtensionScope(extensionId, () => {
+        getExtensionRegistry<T>(entry.registryId).register(
+          entry.key,
+          entry.value,
+          entry.order,
+        );
+      });
+    },
+    defineExpose<T extends object>(value: T) {
+      setExtensionExpose(extensionId, value);
+    },
+  };
+}

package/src/extensions/disabled-folder.ts

@@ -0,0 +1,21 @@
+/** Суффикс имени каталога: расширение в `*.disabled` не загружается лоадером. */
+export const RYNT_EXTENSION_DISABLED_DIR_SUFFIX = '.disabled' as const;
+
+export function isRyntExtensionBundleDirDisabled(dirname: string): boolean {
+  return dirname.endsWith(RYNT_EXTENSION_DISABLED_DIR_SUFFIX);
+}
+
+/** Имя папки без суффикса `.disabled`. */
+export function ryntExtensionBundleDirBaseLabel(dirname: string): string {
+  return isRyntExtensionBundleDirDisabled(dirname)
+    ? dirname.slice(
+        0,
+        dirname.length - RYNT_EXTENSION_DISABLED_DIR_SUFFIX.length,
+      )
+    : dirname;
+}
+
+export function ryntExtensionBundleDisabledFolderName(enabledDirName: string): string {
+  if (isRyntExtensionBundleDirDisabled(enabledDirName)) return enabledDirName;
+  return `${enabledDirName}${RYNT_EXTENSION_DISABLED_DIR_SUFFIX}`;
+}

package/src/extensions/extension-expose-map.ts

@@ -0,0 +1,5 @@
+/**
+ * Карта публичных API расширений по id манифеста.
+ * Дополняется через `declare module` в пакетах расширений-поставщиков.
+ */
+export interface ExtensionExposeMap {}

package/src/extensions/extension-expose.ts

@@ -0,0 +1,48 @@
+import type { ComputedRef } from 'vue';
+import { computed, shallowRef } from 'vue';
+
+import type { ExtensionExposeMap } from '@rynt/sdk/extension-expose-map';
+
+const exposes = new Map<string, unknown>();
+
+/** Для `computed` в компонентах: expose могут появиться после загрузки другого расширения. */
+export const extensionExposeRevision = shallowRef(0);
+
+function bumpExposeRevision(): void {
+  extensionExposeRevision.value += 1;
+}
+
+export function setExtensionExpose(extensionId: string, value: unknown): void {
+  exposes.set(extensionId, value);
+  bumpExposeRevision();
+}
+
+export function clearExtensionExposes(): void {
+  exposes.clear();
+  bumpExposeRevision();
+}
+
+export function clearExtensionExpose(extensionId: string): void {
+  if (exposes.delete(extensionId)) {
+    bumpExposeRevision();
+  }
+}
+
+export function getExtensionExpose<K extends keyof ExtensionExposeMap>(
+  id: K,
+): ExtensionExposeMap[K] | undefined;
+export function getExtensionExpose(id: string): unknown | undefined;
+export function getExtensionExpose(id: string): unknown | undefined {
+  return exposes.get(id);
+}
+
+export function useExtensionExpose<K extends keyof ExtensionExposeMap>(
+  id: K,
+): ComputedRef<ExtensionExposeMap[K] | undefined>;
+export function useExtensionExpose(id: string): ComputedRef<unknown | undefined>;
+export function useExtensionExpose(id: string): ComputedRef<unknown | undefined> {
+  return computed(() => {
+    void extensionExposeRevision.value;
+    return exposes.get(id);
+  });
+}

package/src/extensions/graph.ts

@@ -0,0 +1,67 @@
+import type { ExtensionDependencyGraph } from './manifest-types';
+
+export interface ExtensionTopoNode {
+  id: string;
+}
+
+export interface TopoSortManifest {
+  id: string;
+  extensionDependencies?: Record<string, string>;
+}
+
+/**
+ * Проверка циклов (DFS) и топологический порядок по `extensionDependencies`.
+ */
+export function topoSortExtensions<T extends TopoSortManifest>(
+  manifests: Map<string, T>,
+): { ok: true; order: string[] } | { ok: false; error: string } {
+  const ids = new Set<string>(manifests.keys());
+  const graph: ExtensionDependencyGraph = {};
+  const missingDeps: string[] = [];
+
+  for (const [id, m] of manifests) {
+    const deps = m.extensionDependencies ?? {};
+    graph[id] = { ...deps };
+    for (const depId of Object.keys(deps)) {
+      if (!ids.has(depId)) {
+        missingDeps.push(`${id} depends on unknown extension "${depId}"`);
+      }
+    }
+  }
+
+  if (missingDeps.length > 0) {
+    return { ok: false, error: missingDeps.join('; ') };
+  }
+
+  const visiting = new Set<string>();
+  const visited = new Set<string>();
+  const order: string[] = [];
+
+  const visit = (id: string): void => {
+    if (visited.has(id)) return;
+    if (visiting.has(id)) {
+      throw new Error(`Cycle detected involving "${id}"`);
+    }
+    visiting.add(id);
+    const deps = Object.keys(graph[id] ?? {});
+    for (const dep of deps) {
+      visit(dep);
+    }
+    visiting.delete(id);
+    visited.add(id);
+    order.push(id);
+  };
+
+  try {
+    for (const id of ids) {
+      visit(id);
+    }
+  } catch (e) {
+    return {
+      ok: false,
+      error: e instanceof Error ? e.message : String(e),
+    };
+  }
+
+  return { ok: true, order };
+}