@artinstack/migrator 0.1.3 → 0.1.5

package/dist/sinks/index.d.ts

@@ -1,3 +1,262 @@
-export { C as ConflictReport, D as DryRunOptions, a as DryRunResult, F as FALLBACK_ASSET_BYTES, b as FilesystemMigrationSink, M as MIGRATION_WRITE_STAGES, c as MigrationRedirect, d as MigrationReport, e as MigrationRunMode, f as MigrationRunOptions, g as MigrationRunResult, h as MigrationSink, i as MigrationWriteStage, j as RewriteInlineImagesOptions, k as RewriteInlineImagesResult, S as StorageEstimate, U as UploadAssetInput, l as UploadAssetResult, W as WriteFilesystemOptions, n as analyzeConflicts, o as buildMigrationReport, p as buildRedirectMap, q as bundleToCombinedJson, r as createFilesystemMigrationSink, s as detectRedirectLoops, t as emptyConflictReport, u as estimateStorage, v as hasBlockingConflicts, w as hasWarnings, x as portfolioMediaMatchesBundle, y as rewriteInlineImages, z as runDryRun, A as runMigration, B as runMigrationFromBundle, E as staleUrlsFromEstimate, G as writeFilesystemExport } from '../index-D88mjcF5.js';
-import '../bundle-DfM_jKbq.js';
-import 'node:stream';
+import { d as NormalizedCategory, e as NormalizedTag, b as NormalizedAsset, c as NormalizedPortfolio, N as NormalizedPost, a as NormalizedPage, P as PortfolioMediaLink, E as EntityKey, f as NormalizedEntity, g as MigrationPlatform, M as MigrationAdapter } from '../types-DWOP8Dcy.js';
+import { Readable } from 'node:stream';
+import { a as RewriteInlineImagesOptions } from '../rewrite-inline-images-BckVKPbh.js';
+export { b as RewriteInlineImagesResult, r as rewriteInlineImages } from '../rewrite-inline-images-BckVKPbh.js';
+import { E as EntityBundle } from '../bundle-uAAHehbv.js';
+
+interface CreatePostResult {
+    targetId: string;
+    publicPath: string;
+}
+interface CreatePageResult {
+    targetId: string;
+    publicPath: string;
+}
+interface UploadAssetInput {
+    asset: NormalizedAsset;
+    /** Byte stream from source URL or local file. Optional for metadata-only sinks. */
+    body?: Readable | ReadableStream<Uint8Array>;
+    contentLength?: number;
+}
+interface UploadAssetResult {
+    targetId: string;
+    publicUrl?: string;
+}
+interface MigrationRedirect {
+    fromPath: string;
+    toPath: string;
+    statusCode: number;
+}
+interface MigrationProgress {
+    stage: string;
+    progress: number;
+    message?: string;
+}
+/**
+ * Host-implemented write surface (e.g. ArtInStack PlatformMigrationSink).
+ * This package defines the interface only — no Directus or platform imports.
+ */
+interface MigrationSink {
+    createCategory?(category: NormalizedCategory): Promise<{
+        targetId: string;
+    }>;
+    createTag?(tag: NormalizedTag): Promise<{
+        targetId: string;
+    }>;
+    uploadAsset(input: UploadAssetInput): Promise<UploadAssetResult>;
+    createPortfolio?(portfolio: NormalizedPortfolio): Promise<{
+        targetId: string;
+    }>;
+    createPost(post: NormalizedPost): Promise<CreatePostResult>;
+    createPage(page: NormalizedPage): Promise<CreatePageResult>;
+    linkPortfolioMedia?(link: PortfolioMediaLink): Promise<void>;
+    writeRedirect?(redirect: MigrationRedirect): Promise<void>;
+    reportProgress?(progress: MigrationProgress): Promise<void>;
+    /** Optional lookup for idempotent re-runs. */
+    findExisting?(key: EntityKey): Promise<string | undefined>;
+}
+interface ResolvedAssetStream {
+    body: Readable | ReadableStream<Uint8Array>;
+    contentLength?: number;
+}
+interface MigrationRunOptions {
+    sink: MigrationSink;
+    entities: AsyncIterable<NormalizedEntity>;
+    platform: MigrationPlatform;
+    /** Fetch source bytes before uploadAsset; omit for metadata-only sinks. */
+    resolveAssetStream?: (asset: NormalizedAsset) => Promise<ResolvedAssetStream | null>;
+    /** Rewrite post/page HTML after assets are uploaded. */
+    rewriteInlineImages?: RewriteInlineImagesOptions;
+    onEntityProcessed?: (key: EntityKey, result: "done" | "failed" | "skipped", error?: string) => void;
+}
+interface MigrationRunResult {
+    processed: number;
+    failed: number;
+    skipped: number;
+}
+declare const MIGRATION_WRITE_STAGES: readonly ["taxonomy", "assets", "portfolios", "content", "bindings", "redirects"];
+type MigrationWriteStage = (typeof MIGRATION_WRITE_STAGES)[number];
+
+declare function runMigration(options: MigrationRunOptions): Promise<MigrationRunResult>;
+declare function runMigrationFromBundle(bundle: EntityBundle, options: MigrationRunOptions): Promise<MigrationRunResult>;
+
+interface DuplicateSlugConflict {
+    entityType: "post" | "page";
+    slug: string;
+    sourceIds: string[];
+}
+interface MissingFeaturedImageConflict {
+    postSourceId: string;
+    featuredMediaSourceId: string;
+    reason: string;
+}
+interface StaleAssetUrlConflict {
+    sourceId: string;
+    url: string;
+    reason: string;
+}
+interface InvalidHtmlConflict {
+    entityType: "post" | "page";
+    sourceId: string;
+    issues: string[];
+}
+interface UnresolvedInlineImageConflict {
+    postOrPageSourceId: string;
+    src: string;
+}
+interface UnsupportedBlockConflict {
+    entityType: "post" | "page";
+    sourceId: string;
+    blockType: string;
+    blockId?: string;
+}
+interface RedirectLoopConflict {
+    fromPath: string;
+    toPath: string;
+    blocked: boolean;
+}
+interface ConflictReport {
+    duplicatePostSlugs: DuplicateSlugConflict[];
+    duplicatePageSlugs: DuplicateSlugConflict[];
+    missingFeaturedImages: MissingFeaturedImageConflict[];
+    staleAssetUrls: StaleAssetUrlConflict[];
+    invalidHtml: InvalidHtmlConflict[];
+    unresolvedInlineImages: UnresolvedInlineImageConflict[];
+    unsupportedBlocks: UnsupportedBlockConflict[];
+    redirectLoops: RedirectLoopConflict[];
+}
+declare function emptyConflictReport(): ConflictReport;
+declare function analyzeConflicts(bundle: EntityBundle, options?: {
+    staleAssetUrls?: StaleAssetUrlConflict[];
+    redirectLoops?: RedirectLoopConflict[];
+}): ConflictReport;
+declare function hasBlockingConflicts(report: ConflictReport): boolean;
+declare function hasWarnings(report: ConflictReport): boolean;
+declare function buildRedirectMap(bundle: EntityBundle): {
+    fromPath: string;
+    toPath: string;
+    statusCode: number;
+}[];
+declare function detectRedirectLoops(redirects: {
+    fromPath: string;
+    toPath: string;
+}[]): RedirectLoopConflict[];
+
+type MigrationRunMode = "dry-run" | "export" | "sink" | "worker";
+interface MigrationReport {
+    runId: string;
+    platform: MigrationPlatform;
+    mode: MigrationRunMode;
+    startedAt: string;
+    finishedAt: string;
+    summary: {
+        posts: number;
+        pages: number;
+        assets: number;
+        portfolios: number;
+        categories: number;
+        tags: number;
+        storageBytesEstimated?: number;
+    };
+    warnings: string[];
+    errors: string[];
+    conflicts: ConflictReport;
+    redirectMap: {
+        fromPath: string;
+        toPath: string;
+        statusCode: number;
+    }[];
+}
+declare function buildMigrationReport(input: {
+    platform: MigrationPlatform;
+    mode: MigrationRunMode;
+    bundle: EntityBundle;
+    conflicts: ConflictReport;
+    redirectMap: {
+        fromPath: string;
+        toPath: string;
+        statusCode: number;
+    }[];
+    startedAt: Date;
+    finishedAt?: Date;
+    storageBytesEstimated?: number;
+    warnings?: string[];
+    errors?: string[];
+    runId?: string;
+}): MigrationReport;
+
+interface WriteFilesystemOptions {
+    outDir: string;
+    bundle: EntityBundle;
+    conflicts?: ConflictReport;
+    report?: MigrationReport;
+}
+declare function writeFilesystemExport(options: WriteFilesystemOptions): Promise<void>;
+declare function bundleToCombinedJson(bundle: EntityBundle): Record<string, unknown>;
+
+/** Reference MigrationSink that accumulates entities and writes M0 JSON bundles. */
+declare class FilesystemMigrationSink implements MigrationSink {
+    readonly bundle: EntityBundle;
+    readonly portfolioMediaLinks: PortfolioMediaLink[];
+    readonly redirects: MigrationRedirect[];
+    createCategory(category: NormalizedCategory): Promise<{
+        targetId: string;
+    }>;
+    createTag(tag: NormalizedTag): Promise<{
+        targetId: string;
+    }>;
+    uploadAsset(input: UploadAssetInput): Promise<UploadAssetResult>;
+    createPortfolio(portfolio: NormalizedPortfolio): Promise<{
+        targetId: string;
+    }>;
+    createPost(post: NormalizedPost): Promise<CreatePostResult>;
+    createPage(page: NormalizedPage): Promise<CreatePageResult>;
+    linkPortfolioMedia(link: PortfolioMediaLink): Promise<void>;
+    writeRedirect(redirect: MigrationRedirect): Promise<void>;
+    flush(options: WriteFilesystemOptions): Promise<void>;
+}
+declare function createFilesystemMigrationSink(): FilesystemMigrationSink;
+/** Verify sink-produced M2M links match bundle-derived index. */
+declare function portfolioMediaMatchesBundle(sink: FilesystemMigrationSink): boolean;
+
+interface DryRunOptions {
+    adapter: MigrationAdapter;
+    input: unknown;
+    platform: MigrationPlatform;
+    offlineStorageEstimate?: boolean;
+    fetchFn?: typeof fetch;
+}
+interface DryRunResult {
+    bundle: EntityBundle;
+    conflicts: ConflictReport;
+    report: MigrationReport;
+    exitCode: 0 | 1 | 2;
+}
+declare function runDryRun(options: DryRunOptions): Promise<DryRunResult>;
+
+declare const FALLBACK_ASSET_BYTES: number;
+interface AssetSizeResult {
+    sourceId: string;
+    url: string;
+    bytes: number;
+    source: "head" | "fallback";
+    error?: string;
+}
+interface StorageEstimate {
+    totalBytes: number;
+    assets: AssetSizeResult[];
+}
+interface EstimateStorageOptions {
+    assets: NormalizedAsset[];
+    /** When true, skip network and use fallback for all assets. */
+    offline?: boolean;
+    fetchFn?: typeof fetch;
+}
+declare function estimateStorage(options: EstimateStorageOptions): Promise<StorageEstimate>;
+declare function staleUrlsFromEstimate(estimate: StorageEstimate): {
+    sourceId: string;
+    url: string;
+    reason: string;
+}[];
+
+export { type ConflictReport, type DryRunOptions, type DryRunResult, FALLBACK_ASSET_BYTES, FilesystemMigrationSink, MIGRATION_WRITE_STAGES, type MigrationRedirect, type MigrationReport, type MigrationRunMode, type MigrationRunOptions, type MigrationRunResult, type MigrationSink, type MigrationWriteStage, RewriteInlineImagesOptions, type StorageEstimate, type UploadAssetInput, type UploadAssetResult, type WriteFilesystemOptions, analyzeConflicts, buildMigrationReport, buildRedirectMap, bundleToCombinedJson, createFilesystemMigrationSink, detectRedirectLoops, emptyConflictReport, estimateStorage, hasBlockingConflicts, hasWarnings, portfolioMediaMatchesBundle, runDryRun, runMigration, runMigrationFromBundle, staleUrlsFromEstimate, writeFilesystemExport };

package/dist/sinks/index.js

@@ -13,14 +13,16 @@ import {
   hasBlockingConflicts,
   hasWarnings,
   portfolioMediaMatchesBundle,
-  rewriteInlineImages,
   runDryRun,
   runMigration,
   runMigrationFromBundle,
   staleUrlsFromEstimate,
   writeFilesystemExport
-} from "../chunk-HH7666MQ.js";
+} from "../chunk-YLFVYPB3.js";
 import "../chunk-HI7JHWZU.js";
+import {
+  rewriteInlineImages
+} from "../chunk-S7TRWILI.js";
 import "../chunk-2PNSVE5Y.js";
 export {
   FALLBACK_ASSET_BYTES,

package/dist/transformers/index.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+import { l as ValidationResult } from '../types-DWOP8Dcy.js';
+export { R as RewriteInlineImageRef, a as RewriteInlineImagesOptions, b as RewriteInlineImagesResult, U as UploadedAssetRef, r as rewriteInlineImages } from '../rewrite-inline-images-BckVKPbh.js';
+
+type LayoutKind = "section" | "row" | "column";
+/** Map OSS-2 `data-layout` markers to Grapes component types (host may override). */
+interface LayoutTypeMap {
+    section?: string;
+    row?: string;
+    column?: string;
+}
+interface HtmlToGrapesOptions {
+    /** Map source class names to Grapes component types. */
+    componentMap?: Record<string, string>;
+    /** Map HTML tag names to Grapes component types (e.g. `h2` → `heading`). */
+    tagMap?: Record<string, string>;
+    /** Map `data-layout` section/row/column markers to Grapes component types. */
+    layoutTypeMap?: LayoutTypeMap;
+}
+interface GrapesStyleRule {
+    selectors: string[];
+    style: Record<string, string>;
+}
+interface GrapesComponent {
+    type: string;
+    tagName?: string;
+    attributes?: Record<string, string>;
+    classes?: string[];
+    components?: GrapesComponent[];
+    content?: string;
+    void?: boolean;
+}
+interface GrapesProjectSnapshot {
+    content: GrapesComponent[];
+    styles: GrapesStyleRule[];
+    contentHtml?: string;
+    contentCss?: string;
+}
+
+/** Cheerio HTML walk → Grapes `content` + root `styles`. */
+declare function htmlToGrapes(html: string, options?: HtmlToGrapesOptions): GrapesProjectSnapshot;
+
+/** ProseMirror / Tiptap mark (inline formatting). */
+interface TiptapMark {
+    type: string;
+    attrs?: Record<string, string>;
+}
+/** ProseMirror / Tiptap node — text nodes use `text`; others use `content`. */
+interface TiptapNode {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: TiptapNode[];
+    marks?: TiptapMark[];
+    text?: string;
+}
+/** Root Tiptap document (`content_json` shape). */
+interface TiptapDoc {
+    type: "doc";
+    content: TiptapNode[];
+}
+interface HtmlToTiptapOptions {
+    /**
+     * Unwrap OSS-2 `data-layout` scaffolding (section/row/column divs) into prose blocks.
+     * @default true
+     */
+    unwrapLayoutMarkers?: boolean;
+}
+
+/** Cheerio HTML walk → Tiptap / ProseMirror `doc` JSON for blog `content_json`. */
+declare function htmlToTiptap(html: string, options?: HtmlToTiptapOptions): TiptapDoc;
+
+/** Parse `<style>` blocks and class rules into Grapes root `styles[]`. */
+declare function cssToStyles(css: string): GrapesStyleRule[];
+
+declare const grapesStyleRuleSchema: z.ZodObject<{
+    selectors: z.ZodArray<z.ZodString, "many">;
+    style: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    style: Record<string, string>;
+    selectors: string[];
+}, {
+    style: Record<string, string>;
+    selectors: string[];
+}>;
+declare const grapesComponentSchema: z.ZodType<GrapesComponent>;
+declare const grapesProjectSnapshotSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodType<GrapesComponent, z.ZodTypeDef, GrapesComponent>, "many">;
+    styles: z.ZodArray<z.ZodObject<{
+        selectors: z.ZodArray<z.ZodString, "many">;
+        style: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        style: Record<string, string>;
+        selectors: string[];
+    }, {
+        style: Record<string, string>;
+        selectors: string[];
+    }>, "many">;
+    contentHtml: z.ZodOptional<z.ZodString>;
+    contentCss: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: GrapesComponent[];
+    styles: {
+        style: Record<string, string>;
+        selectors: string[];
+    }[];
+    contentHtml?: string | undefined;
+    contentCss?: string | undefined;
+}, {
+    content: GrapesComponent[];
+    styles: {
+        style: Record<string, string>;
+        selectors: string[];
+    }[];
+    contentHtml?: string | undefined;
+    contentCss?: string | undefined;
+}>;
+interface ValidateGrapesProjectSnapshotOptions {
+    /** When set, every component `type` in the tree must be in this allowlist. */
+    allowedComponentTypes?: string[];
+}
+/**
+ * Opt-in structural check for a Grapes project snapshot (not a full Grapes editor project file).
+ * Does not validate host-specific component registries unless `allowedComponentTypes` is passed.
+ */
+declare function validateGrapesProjectSnapshot(snapshot: unknown, options?: ValidateGrapesProjectSnapshotOptions): ValidationResult;
+
+declare const tiptapMarkSchema: z.ZodObject<{
+    type: z.ZodString;
+    attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    attrs?: Record<string, string> | undefined;
+}, {
+    type: string;
+    attrs?: Record<string, string> | undefined;
+}>;
+declare const tiptapNodeSchema: z.ZodType<TiptapNode>;
+declare const tiptapDocSchema: z.ZodObject<{
+    type: z.ZodLiteral<"doc">;
+    content: z.ZodArray<z.ZodType<TiptapNode, z.ZodTypeDef, TiptapNode>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "doc";
+    content: TiptapNode[];
+}, {
+    type: "doc";
+    content: TiptapNode[];
+}>;
+interface ValidateTiptapDocOptions {
+    /** When set, every node `type` in the tree must be in this allowlist. */
+    allowedNodeTypes?: string[];
+    /** When set, every mark `type` must be in this allowlist. */
+    allowedMarkTypes?: string[];
+}
+/** Opt-in structural check for a Tiptap / ProseMirror document. */
+declare function validateTiptapDoc(doc: unknown, options?: ValidateTiptapDocOptions): ValidationResult;
+
+export { type GrapesComponent, type GrapesProjectSnapshot, type GrapesStyleRule, type HtmlToGrapesOptions, type HtmlToTiptapOptions, type LayoutKind, type LayoutTypeMap, type TiptapDoc, type TiptapMark, type TiptapNode, type ValidateGrapesProjectSnapshotOptions, type ValidateTiptapDocOptions, cssToStyles, grapesComponentSchema, grapesProjectSnapshotSchema, grapesStyleRuleSchema, htmlToGrapes, htmlToTiptap, tiptapDocSchema, tiptapMarkSchema, tiptapNodeSchema, validateGrapesProjectSnapshot, validateTiptapDoc };

package/dist/transformers/index.js

@@ -0,0 +1,32 @@
+import {
+  cssToStyles,
+  grapesComponentSchema,
+  grapesProjectSnapshotSchema,
+  grapesStyleRuleSchema,
+  htmlToGrapes,
+  htmlToTiptap,
+  tiptapDocSchema,
+  tiptapMarkSchema,
+  tiptapNodeSchema,
+  validateGrapesProjectSnapshot,
+  validateTiptapDoc
+} from "../chunk-CIOYDRY5.js";
+import {
+  rewriteInlineImages
+} from "../chunk-S7TRWILI.js";
+import "../chunk-2PNSVE5Y.js";
+export {
+  cssToStyles,
+  grapesComponentSchema,
+  grapesProjectSnapshotSchema,
+  grapesStyleRuleSchema,
+  htmlToGrapes,
+  htmlToTiptap,
+  rewriteInlineImages,
+  tiptapDocSchema,
+  tiptapMarkSchema,
+  tiptapNodeSchema,
+  validateGrapesProjectSnapshot,
+  validateTiptapDoc
+};
+//# sourceMappingURL=index.js.map

package/dist/transformers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{bundle-DfM_jKbq.d.ts → types-DWOP8Dcy.d.ts}

@@ -130,24 +130,4 @@ interface EntityKey {
 }
 declare function entityKey(entity: NormalizedEntity, platform: MigrationPlatform): EntityKey;
 
-interface EntityBundle {
-    posts: NormalizedPost[];
-    pages: NormalizedPage[];
-    media: NormalizedAsset[];
-    portfolios: NormalizedPortfolio[];
-    categories: NormalizedCategory[];
-    tags: NormalizedTag[];
-}
-declare function emptyBundle(): EntityBundle;
-declare function collectEntities(entities: AsyncIterable<NormalizedEntity>): Promise<EntityBundle>;
-interface BundleCounts {
-    posts: number;
-    pages: number;
-    assets: number;
-    portfolios: number;
-    categories: number;
-    tags: number;
-}
-declare function bundleCounts(bundle: EntityBundle): BundleCounts;
-
-export { type AdapterContext as A, type BundleCounts as B, type EntityBundle as E, type MigrationAdapter as M, type NormalizedAsset as N, type PortfolioMediaLink as P, type SourceMetadata as S, type ValidationResult as V, type MigrationPlatform as a, type EntityKey as b, type EntityType as c, type MigrationCursor as d, type NormalizedAssetExif as e, type NormalizedCategory as f, type NormalizedEntity as g, type NormalizedPage as h, type NormalizedPortfolio as i, type NormalizedPost as j, type NormalizedTag as k, type PublishStatus as l, type ValidationIssue as m, bundleCounts as n, collectEntities as o, emptyBundle as p, entityKey as q };
+export { type AdapterContext as A, type EntityKey as E, type MigrationAdapter as M, type NormalizedPost as N, type PortfolioMediaLink as P, type SourceMetadata as S, type ValidationIssue as V, type NormalizedPage as a, type NormalizedAsset as b, type NormalizedPortfolio as c, type NormalizedCategory as d, type NormalizedTag as e, type NormalizedEntity as f, type MigrationPlatform as g, type EntityType as h, type MigrationCursor as i, type NormalizedAssetExif as j, type PublishStatus as k, type ValidationResult as l, entityKey as m };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artinstack/migrator",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Stateless content normalizer and migration framework — WordPress, SmugMug, Squarespace → platform-agnostic schema",
   "license": "MIT",
   "author": "ArtInStack",
@@ -46,6 +46,10 @@
     "./lib": {
       "types": "./dist/lib/index.d.ts",
       "import": "./dist/lib/index.js"
+    },
+    "./transformers": {
+      "types": "./dist/transformers/index.d.ts",
+      "import": "./dist/transformers/index.js"
     }
   },
   "bin": {