handoff-app 1.2.2-7 → 2.0.0-1

package/dist/store/registry.js

@@ -0,0 +1,350 @@
+"use strict";
+/**
+ * Database-backed implementation of the normalized store abstraction.
+ *
+ * Registry mode serves only what was published to it: this store reads normalized component and
+ * pattern records — and their checkout/inspection source files — straight from the registry
+ * database. It is the registry counterpart to {@link FilesystemComponentStore},
+ * so the docs read API and other consumers stay storage-agnostic.
+ *
+ * Two invariants hold here that the filesystem store does not enforce:
+ * - Filesystem workspace declarations are never loaded as registry content; declarations are
+ *   workspace-only (synthesized on checkout) and the registry text-file tables reject the
+ *   `declaration` kind at the schema level, so they can never surface through this store.
+ * - Reads never materialize source files or run the build pipeline — every record and file is
+ *   returned exactly as it was published.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegistryStore = exports.RegistryAssetStore = exports.RegistryTokenStore = exports.RegistryPageStore = exports.RegistryPatternStore = exports.RegistryComponentStore = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const schema_1 = require("../registry/db/schema");
+/**
+ * Map a persisted file row to a {@link TextFileResource}. Rows whose content is stored externally
+ * (a future object-storage `storageRef` with no inline `content`) are skipped — there is nothing to
+ * return inline for them yet. Registry records have no filesystem location, so `absolutePath` is
+ * empty (it is documented as workspace-store-only on the type).
+ */
+const toTextFileResource = (row) => {
+    if (row.content == null) {
+        return null;
+    }
+    return {
+        path: row.path,
+        absolutePath: '',
+        kind: row.kind,
+        content: row.content,
+        contentType: row.contentType,
+    };
+};
+class RegistryComponentStore {
+    constructor(context) {
+        this.context = context;
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db.select({ record: schema_1.components.record }).from(schema_1.components);
+            return rows.map((row) => row.record);
+        });
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const rows = yield this.context.db
+                .select({ record: schema_1.components.record })
+                .from(schema_1.components)
+                .where((0, drizzle_orm_1.eq)(schema_1.components.id, id))
+                .limit(1);
+            return (_b = (_a = rows[0]) === null || _a === void 0 ? void 0 : _a.record) !== null && _b !== void 0 ? _b : null;
+        });
+    }
+    /**
+     * Registry source files are keyed by `(entity, path)`, not by an absolute filesystem path, so the
+     * filesystem-shaped {@link SourceReference} has no resolvable target here. Related files are read
+     * through {@link getRelatedSourceFiles}.
+     */
+    getSource(_ref) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    }
+    getRelatedSourceFiles(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db
+                .select({
+                path: schema_1.componentFiles.path,
+                kind: schema_1.componentFiles.kind,
+                content: schema_1.componentFiles.content,
+                contentType: schema_1.componentFiles.contentType,
+            })
+                .from(schema_1.componentFiles)
+                .where((0, drizzle_orm_1.eq)(schema_1.componentFiles.componentId, id));
+            return rows.map(toTextFileResource).filter((file) => file !== null);
+        });
+    }
+}
+exports.RegistryComponentStore = RegistryComponentStore;
+class RegistryPatternStore {
+    constructor(context) {
+        this.context = context;
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db.select({ record: schema_1.patterns.record }).from(schema_1.patterns);
+            return rows.map((row) => row.record);
+        });
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const rows = yield this.context.db
+                .select({ record: schema_1.patterns.record })
+                .from(schema_1.patterns)
+                .where((0, drizzle_orm_1.eq)(schema_1.patterns.id, id))
+                .limit(1);
+            return (_b = (_a = rows[0]) === null || _a === void 0 ? void 0 : _a.record) !== null && _b !== void 0 ? _b : null;
+        });
+    }
+    getSource(_ref) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    }
+    getRelatedSourceFiles(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db
+                .select({
+                path: schema_1.patternFiles.path,
+                kind: schema_1.patternFiles.kind,
+                content: schema_1.patternFiles.content,
+                contentType: schema_1.patternFiles.contentType,
+            })
+                .from(schema_1.patternFiles)
+                .where((0, drizzle_orm_1.eq)(schema_1.patternFiles.patternId, id));
+            return rows.map(toTextFileResource).filter((file) => file !== null);
+        });
+    }
+}
+exports.RegistryPatternStore = RegistryPatternStore;
+class RegistryPageStore {
+    constructor(context) {
+        this.context = context;
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db.select({ record: schema_1.pages.record }).from(schema_1.pages);
+            return rows.map((row) => row.record);
+        });
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const rows = yield this.context.db.select({ record: schema_1.pages.record }).from(schema_1.pages).where((0, drizzle_orm_1.eq)(schema_1.pages.id, id)).limit(1);
+            return (_b = (_a = rows[0]) === null || _a === void 0 ? void 0 : _a.record) !== null && _b !== void 0 ? _b : null;
+        });
+    }
+    getSource(_ref) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    }
+    getRelatedSourceFiles(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db
+                .select({
+                path: schema_1.pageFiles.path,
+                kind: schema_1.pageFiles.kind,
+                content: schema_1.pageFiles.content,
+                contentType: schema_1.pageFiles.contentType,
+            })
+                .from(schema_1.pageFiles)
+                .where((0, drizzle_orm_1.eq)(schema_1.pageFiles.pageId, id));
+            return rows.map(toTextFileResource).filter((file) => file !== null);
+        });
+    }
+}
+exports.RegistryPageStore = RegistryPageStore;
+class RegistryTokenStore {
+    constructor(context) {
+        this.context = context;
+    }
+    listSets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db.select({ id: schema_1.tokenSets.id, kind: schema_1.tokenSets.kind, record: schema_1.tokenSets.record }).from(schema_1.tokenSets);
+            return rows.map((row) => ({ id: row.id, kind: row.kind, record: row.record }));
+        });
+    }
+    getSet(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db
+                .select({ id: schema_1.tokenSets.id, kind: schema_1.tokenSets.kind, record: schema_1.tokenSets.record })
+                .from(schema_1.tokenSets)
+                .where((0, drizzle_orm_1.eq)(schema_1.tokenSets.id, id))
+                .limit(1);
+            const row = rows[0];
+            return row ? { id: row.id, kind: row.kind, record: row.record } : null;
+        });
+    }
+    getArtifacts(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db
+                .select({ path: schema_1.tokenArtifacts.path, format: schema_1.tokenArtifacts.format, content: schema_1.tokenArtifacts.content, contentType: schema_1.tokenArtifacts.contentType })
+                .from(schema_1.tokenArtifacts)
+                .where((0, drizzle_orm_1.eq)(schema_1.tokenArtifacts.tokenSetId, id));
+            return rows
+                .filter((row) => row.content != null)
+                .map((row) => ({ path: row.path, format: row.format, content: row.content, contentType: row.contentType }));
+        });
+    }
+    getArtifact(id, format) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = (yield this.getArtifacts(id)).find((artifact) => artifact.format === format)) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+}
+exports.RegistryTokenStore = RegistryTokenStore;
+const readableToBuffer = (stream) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, stream_1, stream_1_1;
+    var _b, e_1, _c, _d;
+    const chunks = [];
+    try {
+        for (_a = true, stream_1 = __asyncValues(stream); stream_1_1 = yield stream_1.next(), _b = stream_1_1.done, !_b; _a = true) {
+            _d = stream_1_1.value;
+            _a = false;
+            const chunk = _d;
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : typeof chunk === 'string' ? Buffer.from(chunk) : Buffer.from(chunk));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_a && !_b && (_c = stream_1.return)) yield _c.call(stream_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return Buffer.concat(chunks);
+});
+class RegistryAssetStore {
+    constructor(context) {
+        this.context = context;
+    }
+    listCollections() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db.select({ collection: schema_1.assetCollections.collection }).from(schema_1.assetCollections);
+            return rows.map((row) => row.collection);
+        });
+    }
+    listAssets(collection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.context.db
+                .select({
+                collection: schema_1.assets.collection,
+                path: schema_1.assets.path,
+                name: schema_1.assets.name,
+                contentType: schema_1.assets.contentType,
+                size: schema_1.assets.size,
+                contentHash: schema_1.assets.contentHash,
+                metadata: schema_1.assets.metadata,
+            })
+                .from(schema_1.assets)
+                .where((0, drizzle_orm_1.eq)(schema_1.assets.collection, collection));
+            return rows.map((row) => {
+                var _a, _b;
+                return ({
+                    collection: row.collection,
+                    path: row.path,
+                    name: row.name,
+                    contentType: row.contentType,
+                    size: (_a = row.size) !== null && _a !== void 0 ? _a : 0,
+                    contentHash: row.contentHash,
+                    metadata: (_b = row.metadata) !== null && _b !== void 0 ? _b : null,
+                });
+            });
+        });
+    }
+    getAsset(collection, assetPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = (yield this.listAssets(collection)).find((asset) => asset.path === assetPath)) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    getAssetContent(collection, assetPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const rows = yield this.context.db
+                .select({
+                name: schema_1.assets.name,
+                contentType: schema_1.assets.contentType,
+                size: schema_1.assets.size,
+                contentHash: schema_1.assets.contentHash,
+                metadata: schema_1.assets.metadata,
+                blobContent: schema_1.assetBlobs.content,
+                storageRef: schema_1.assetBlobs.storageRef,
+                storageProvider: schema_1.assetBlobs.storageProvider,
+            })
+                .from(schema_1.assets)
+                .innerJoin(schema_1.assetBlobs, (0, drizzle_orm_1.eq)(schema_1.assets.blobHash, schema_1.assetBlobs.hash))
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.assets.collection, collection), (0, drizzle_orm_1.eq)(schema_1.assets.path, assetPath)))
+                .limit(1);
+            const row = rows[0];
+            if (!row) {
+                return null;
+            }
+            const base = {
+                collection,
+                path: assetPath,
+                name: row.name,
+                contentType: row.contentType,
+                size: (_a = row.size) !== null && _a !== void 0 ? _a : 0,
+                contentHash: row.contentHash,
+                metadata: (_b = row.metadata) !== null && _b !== void 0 ? _b : null,
+            };
+            // Inline (bytea, `database` provider) - return bytes directly.
+            if (row.blobContent != null) {
+                return Object.assign(Object.assign({}, base), { body: Buffer.from(row.blobContent) });
+            }
+            // Object-backed - resolve through the provider that stored it.
+            if (!row.storageRef || !this.context.resolveAssetAdapter) {
+                return null;
+            }
+            const adapter = yield this.context.resolveAssetAdapter(row.storageProvider);
+            if (!adapter) {
+                return null;
+            }
+            const result = yield adapter.get(row.storageRef);
+            if (result.kind === 'redirect') {
+                return Object.assign(Object.assign({}, base), { redirectUrl: result.url });
+            }
+            if (result.kind === 'bytes') {
+                return Object.assign(Object.assign({}, base), { body: result.bytes });
+            }
+            return Object.assign(Object.assign({}, base), { body: yield readableToBuffer(result.stream) });
+        });
+    }
+}
+exports.RegistryAssetStore = RegistryAssetStore;
+/** Build the database-backed store set for a registry database connection. */
+const createRegistryStore = (context) => ({
+    components: new RegistryComponentStore(context),
+    patterns: new RegistryPatternStore(context),
+    pages: new RegistryPageStore(context),
+    tokens: new RegistryTokenStore(context),
+    assets: new RegistryAssetStore(context),
+});
+exports.createRegistryStore = createRegistryStore;

package/dist/store/source-files.d.ts

@@ -0,0 +1,24 @@
+/**
+ * First-class "related source files for an entity" accessor for the workspace store.
+ *
+ * Gathers an entity's declaration plus every `entries`-referenced source file for checkout and
+ * publish. This centralizes that logic so the store, and later transfer, share one definition of
+ * "what travels with an entity".
+ */
+import type { ComponentListObject, PatternListObject } from '../transformers/preview/types';
+import type { RegistryTextFileResource, TextFileResource } from './types';
+/** A normalized record carrying a source directory `path` and resolved absolute `entries`. */
+type SourcedRecord = (ComponentListObject | PatternListObject) & {
+    entries?: Record<string, string | undefined>;
+};
+export declare const sourceContentTypeForPath: (filePath: string) => string;
+/**
+ * Gather an entity's declaration plus every `entries`-referenced source file. Files are deduped by
+ * normalized absolute path (entries duplicate `template`/`component`/`story` after normalization),
+ * and a `templates` directory entry is expanded into its files. Declaration always sorts first.
+ */
+export declare const getRelatedSourceFilesForRecord: (record: SourcedRecord) => TextFileResource[];
+/** Whether a file resource should be excluded from registry source records (declarations only). */
+export declare const isWorkspaceOnlyFile: (file: TextFileResource) => boolean;
+export declare const isRegistrySourceFile: (file: TextFileResource) => file is RegistryTextFileResource;
+export {};

package/dist/store/source-files.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * First-class "related source files for an entity" accessor for the workspace store.
+ *
+ * Gathers an entity's declaration plus every `entries`-referenced source file for checkout and
+ * publish. This centralizes that logic so the store, and later transfer, share one definition of
+ * "what travels with an entity".
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRegistrySourceFile = exports.isWorkspaceOnlyFile = exports.getRelatedSourceFilesForRecord = exports.sourceContentTypeForPath = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const runtime_1 = require("../config/runtime");
+const path_2 = require("../utils/path");
+/** Maps a component/pattern `entries` key to the source-file kind it contributes. */
+const ENTRY_KIND_BY_KEY = {
+    js: 'script',
+    scss: 'style',
+    component: 'component',
+    story: 'story',
+    schema: 'schema',
+    template: 'template',
+    templates: 'template',
+};
+/** Source-text content types keyed by file extension (lowercase, no dot). */
+const SOURCE_CONTENT_TYPE_BY_EXT = {
+    ts: 'text/typescript; charset=utf-8',
+    tsx: 'text/typescript; charset=utf-8',
+    js: 'application/javascript; charset=utf-8',
+    jsx: 'application/javascript; charset=utf-8',
+    cjs: 'application/javascript; charset=utf-8',
+    mjs: 'application/javascript; charset=utf-8',
+    json: 'application/json; charset=utf-8',
+    css: 'text/css; charset=utf-8',
+    scss: 'text/x-scss; charset=utf-8',
+    sass: 'text/x-sass; charset=utf-8',
+    hbs: 'text/x-handlebars-template; charset=utf-8',
+    md: 'text/markdown; charset=utf-8',
+    html: 'text/html; charset=utf-8',
+};
+const sourceContentTypeForPath = (filePath) => {
+    var _a;
+    const ext = path_1.default.extname(filePath).slice(1).toLowerCase();
+    return (_a = SOURCE_CONTENT_TYPE_BY_EXT[ext]) !== null && _a !== void 0 ? _a : 'text/plain; charset=utf-8';
+};
+exports.sourceContentTypeForPath = sourceContentTypeForPath;
+/**
+ * Read a single text source file into a {@link TextFileResource}, or `null` when it is missing or
+ * unreadable. `relativeTo` is the entity source directory used to derive the registry-safe path.
+ */
+const readTextFile = (absolutePath, kind, relativeTo) => {
+    try {
+        if (!fs_extra_1.default.existsSync(absolutePath) || !fs_extra_1.default.statSync(absolutePath).isFile()) {
+            return null;
+        }
+        const content = fs_extra_1.default.readFileSync(absolutePath, 'utf8');
+        const relative = path_1.default.relative(relativeTo, absolutePath).split(path_1.default.sep).join('/');
+        return {
+            path: relative || path_1.default.basename(absolutePath),
+            absolutePath,
+            kind,
+            content,
+            contentType: (0, exports.sourceContentTypeForPath)(absolutePath),
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+/** Expand a `templates` directory entry into its contained template files. */
+const expandTemplatesDir = (dirPath) => {
+    try {
+        if (!fs_extra_1.default.existsSync(dirPath) || !fs_extra_1.default.statSync(dirPath).isDirectory()) {
+            return [];
+        }
+        return fs_extra_1.default
+            .readdirSync(dirPath, { withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .map((entry) => path_1.default.join(dirPath, entry.name));
+    }
+    catch (_a) {
+        return [];
+    }
+};
+/**
+ * Locate the entity's declaration file within its source directory and read it as a
+ * `kind: 'declaration'` resource. Returns `null` when no declaration can be found/read.
+ */
+const readDeclarationFile = (sourceDir) => {
+    const declaration = (0, runtime_1.resolveComponentDeclaration)(sourceDir, path_1.default.basename(sourceDir));
+    if (!declaration)
+        return null;
+    const absolutePath = path_1.default.resolve(sourceDir, declaration.fileName);
+    return readTextFile(absolutePath, 'declaration', sourceDir);
+};
+/**
+ * Gather an entity's declaration plus every `entries`-referenced source file. Files are deduped by
+ * normalized absolute path (entries duplicate `template`/`component`/`story` after normalization),
+ * and a `templates` directory entry is expanded into its files. Declaration always sorts first.
+ */
+const getRelatedSourceFilesForRecord = (record) => {
+    var _a, _b;
+    const sourceDir = record.path;
+    if (!sourceDir) {
+        return [];
+    }
+    const collected = [];
+    const seen = new Set();
+    const add = (absolutePath, kind) => {
+        const key = (0, path_2.normalizePathForCompare)(absolutePath);
+        if (seen.has(key))
+            return;
+        const resource = readTextFile(absolutePath, kind, sourceDir);
+        if (!resource)
+            return;
+        seen.add(key);
+        collected.push(resource);
+    };
+    const declaration = readDeclarationFile(sourceDir);
+    if (declaration) {
+        seen.add((0, path_2.normalizePathForCompare)(declaration.absolutePath));
+        collected.push(declaration);
+    }
+    const entries = (_a = record.entries) !== null && _a !== void 0 ? _a : {};
+    for (const [key, value] of Object.entries(entries)) {
+        if (!value)
+            continue;
+        const kind = (_b = ENTRY_KIND_BY_KEY[key]) !== null && _b !== void 0 ? _b : 'other';
+        if (key === 'templates') {
+            for (const templateFile of expandTemplatesDir(value)) {
+                add(templateFile, 'template');
+            }
+            continue;
+        }
+        add(value, kind);
+    }
+    return collected;
+};
+exports.getRelatedSourceFilesForRecord = getRelatedSourceFilesForRecord;
+/** Whether a file resource should be excluded from registry source records (declarations only). */
+const isWorkspaceOnlyFile = (file) => file.kind === 'declaration';
+exports.isWorkspaceOnlyFile = isWorkspaceOnlyFile;
+const isRegistrySourceFile = (file) => !(0, exports.isWorkspaceOnlyFile)(file);
+exports.isRegistrySourceFile = isRegistrySourceFile;