@xpert-ai/plugin-spaces 0.0.0-stage → 0.2.0

package/dist/documents.js

@@ -0,0 +1,158 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { BadRequestException, ConflictException, Inject, Injectable } from '@nestjs/common';
+import { ContentDocumentsRuntimeCapability, ProjectFilesRuntimeCapability, XPERT_RUNTIME_CAPABILITIES_TOKEN } from '@xpert-ai/plugin-sdk';
+import { createHash, randomUUID } from 'node:crypto';
+import { SpaceAccess } from './access.js';
+import { denied, scoped } from './domain.js';
+export const contentHash = (buffer) => createHash('sha256').update(buffer).digest('hex');
+export const safeName = (name) => name.replace(/[\\/\u0000-\u001f]/gu, '_').replace(/^\.+/u, '_').slice(0, 180) || 'Untitled';
+/** Runtime memory and Space checkpoints are infrastructure, not library content. */
+export const isInternalSpacePath = (filePath) => ['.xpert', '.space-history', '.space-trash'].includes(filePath.split('/')[0]);
+/** Project files are the portable content; Space rows retain collaboration and presentation metadata. */
+let SpaceDocuments = class SpaceDocuments {
+    access;
+    runtime;
+    constructor(access, runtime) {
+        this.access = access;
+        this.runtime = runtime;
+    }
+    content() { return this.runtime.require(ContentDocumentsRuntimeCapability); }
+    api() { return this.runtime.require(ProjectFilesRuntimeCapability); }
+    scope(actor, space) {
+        if (!space.projectId)
+            throw denied();
+        return { actor, projectId: space.projectId };
+    }
+    async path(actor, item) {
+        const parent = item.parentId ? await this.access.items.findOneByOrFail({ ...scoped(actor), id: item.parentId }) : null;
+        if (parent && (parent.kind !== 'folder' || !parent.filePath))
+            throw denied();
+        const name = safeName(item.title);
+        return `${parent?.filePath ? `${parent.filePath}/` : ''}${item.kind === 'page' && !name.endsWith('.md') ? `${name}.md` : name}`;
+    }
+    async initialize(actor, space, item, content) {
+        if (!space.projectId)
+            throw denied();
+        if (item.kind === 'page')
+            await this.content().validateImport({ ...this.scope(actor, space),
+                assistantId: actor.assistantId, modelKey: 'markdown.tiptap', markdown: content?.toString('utf8') ?? '' });
+        const filePath = await this.path(actor, item);
+        await this.access.items.update(item.id, { filePath });
+        let sha256 = null;
+        if (item.kind === 'folder')
+            await this.api().mkdir({ ...this.scope(actor, space), path: filePath });
+        else if (content)
+            ({ sha256 } = await this.api().write({ ...this.scope(actor, space), path: filePath, buffer: content, expectedHash: null }));
+        await this.access.items.update(item.id, { filePath, fileHash: sha256, syncStatus: content || item.kind === 'folder' ? 'ready' : 'pending' });
+        Object.assign(item, { filePath, fileHash: sha256 });
+        if (item.kind === 'page')
+            await this.registerPage(actor, space, item);
+        return item;
+    }
+    /** Register the file on creation/discovery; opening a page never migrates or mutates its model. */
+    async registerPage(actor, space, item) {
+        if (!item.filePath)
+            throw denied();
+        await this.content().register({ ...this.scope(actor, space), assistantId: actor.assistantId,
+            resourceId: item.id, path: item.filePath, title: item.title, modelKey: 'markdown.tiptap',
+            source: { providerKey: 'spaces', resourceId: item.id } });
+        await this.access.items.update(item.id, { editorKey: 'markdown.tiptap' });
+        item.editorKey = 'markdown.tiptap';
+    }
+    async write(actor, itemId, buffer) {
+        const { space, item } = await this.access.resource(actor, itemId, 'write');
+        if (!space.projectId || !item?.filePath)
+            throw denied();
+        if (item.editorKey === 'markdown.tiptap')
+            throw new ConflictException('spaces.editor_api_required');
+        const { sha256 } = await this.api().write({ ...this.scope(actor, space), path: item.filePath, buffer, expectedHash: item.fileHash });
+        await this.access.items.update(item.id, { fileHash: sha256, syncStatus: 'ready', syncError: null });
+        return { sha256, filePath: item.filePath, projectId: space.projectId };
+    }
+    async read(actor, space, item) {
+        if (!space.projectId)
+            throw denied();
+        if (!item.filePath)
+            return null;
+        return this.api().read({ ...this.scope(actor, space), path: item.filePath });
+    }
+    async editableMarkdown(actor, space, buffer) {
+        try {
+            await this.content().validateImport({ ...this.scope(actor, space), assistantId: actor.assistantId,
+                modelKey: 'markdown.tiptap', markdown: buffer.toString('utf8') });
+            return true;
+        }
+        catch (error) {
+            // Unsupported portable Markdown remains a downloadable file; permission/infrastructure errors propagate.
+            if (error instanceof BadRequestException)
+                return false;
+            throw error;
+        }
+    }
+    /** Discover files created by other Assistants without importing hidden version/trash storage. */
+    async discover(actor, space, canWrite) {
+        if (!space.projectId)
+            throw denied();
+        const files = await this.api().list({ ...this.scope(actor, space), depth: 12 });
+        const existing = await this.access.items.findBy({ ...scoped(actor), spaceId: space.id });
+        if (existing.some((item) => item.syncError === 'spaces.location_pending'))
+            return;
+        const byPath = new Map(existing.filter((item) => item.filePath && !item.deleted).map((item) => [item.filePath, item]));
+        for (const file of files.sort((a, b) => a.path.split('/').length - b.path.split('/').length)) {
+            if (isInternalSpacePath(file.path))
+                continue;
+            const known = byPath.get(file.path);
+            if (known) {
+                // Resume a first registration interrupted after inserting the navigation row.
+                // Readers can discover portable files; only editors may initialize collaborative state.
+                if (canWrite && !known.editorKey && (known.kind === 'page' ||
+                    (known.kind === 'file' && file.path.endsWith('.md') && file.size <= 100000))) {
+                    const source = await this.api().read({ ...this.scope(actor, space), path: file.path });
+                    if (await this.editableMarkdown(actor, space, source.buffer)) {
+                        await this.registerPage(actor, space, known);
+                        await this.access.items.update(known.id, { kind: 'page' });
+                    }
+                }
+                continue;
+            }
+            const parentPath = file.path.includes('/') ? file.path.slice(0, file.path.lastIndexOf('/')) : '';
+            const parentId = parentPath ? byPath.get(parentPath)?.id : null;
+            if (parentPath && !parentId)
+                continue;
+            const name = file.path.split('/').pop();
+            let kind = file.kind === 'directory' ? 'folder' : canWrite && name.endsWith('.md') && file.size <= 100000 ? 'page' : 'file';
+            const content = kind === 'page' ? await this.api().read({ ...this.scope(actor, space), path: file.path }) : null;
+            if (content && !(await this.editableMarkdown(actor, space, content.buffer)))
+                kind = 'file';
+            {
+                await this.access.items.createQueryBuilder().insert().values({
+                    ...scoped(actor), spaceId: space.id, id: randomUUID(), parentId: parentId ?? null,
+                    createdById: actor.userId, title: kind === 'page' ? name.slice(0, -3) : name, kind,
+                    filePath: file.path, fileHash: content?.sha256 ?? null,
+                    markdown: content?.buffer.toString('utf8') ?? '', syncStatus: 'ready'
+                }).orIgnore().execute();
+                const item = await this.access.items.findOneByOrFail({ ...scoped(actor), spaceId: space.id, filePath: file.path, deleted: false });
+                if (kind === 'page')
+                    await this.registerPage(actor, space, item);
+                byPath.set(file.path, item);
+            }
+        }
+    }
+};
+SpaceDocuments = __decorate([
+    Injectable(),
+    __param(1, Inject(XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [SpaceAccess, Object])
+], SpaceDocuments);
+export { SpaceDocuments };

package/dist/domain.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod/v3';
+import { ForbiddenException } from '@nestjs/common';
+import type { ContentActor, ContentOperation } from '@xpert-ai/plugin-sdk';
+export declare const PLUGIN = "@xpert-ai/plugin-spaces";
+export declare const PROVIDER = "spaces";
+export declare const VIEW = "spaces.workspace";
+export declare const id: z.ZodString;
+export declare const title: z.ZodString;
+export declare const actorSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    organizationId: z.ZodString;
+    userId: z.ZodString;
+    assistantId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    tenantId: string;
+    organizationId: string;
+    userId: string;
+    assistantId?: string | undefined;
+    projectId?: string | undefined;
+}, {
+    tenantId: string;
+    organizationId: string;
+    userId: string;
+    assistantId?: string | undefined;
+    projectId?: string | undefined;
+}>;
+export type SpaceActor = ContentActor & {
+    assistantId?: string;
+    projectId?: string;
+};
+export declare const roleSchema: z.ZodEnum<["viewer", "commenter", "editor", "manager", "owner"]>;
+export type Role = z.infer<typeof roleSchema>;
+export declare const rank: Record<Role, number>;
+export declare const required: Record<ContentOperation, number>;
+export declare const kindSchema: z.ZodEnum<["folder", "page", "file", "artifact"]>;
+export type ItemKind = z.infer<typeof kindSchema>;
+export declare const blockSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<["paragraph", "heading", "code", "bullet"]>;
+    text: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    kind: "code" | "paragraph" | "heading" | "bullet";
+    text: string;
+}, {
+    id: string;
+    kind: "code" | "paragraph" | "heading" | "bullet";
+    text: string;
+}>;
+export declare const blocksSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<["paragraph", "heading", "code", "bullet"]>;
+    text: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    kind: "code" | "paragraph" | "heading" | "bullet";
+    text: string;
+}, {
+    id: string;
+    kind: "code" | "paragraph" | "heading" | "bullet";
+    text: string;
+}>, "many">;
+export type Block = z.infer<typeof blockSchema>;
+export declare const patchSchema: z.ZodObject<{
+    itemId: z.ZodString;
+    mutationId: z.ZodString;
+    expectedSequence: z.ZodNumber;
+    blockId: z.ZodString;
+    before: z.ZodString;
+    after: z.ZodString;
+    reason: z.ZodDefault<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    itemId: string;
+    mutationId: string;
+    expectedSequence: number;
+    blockId: string;
+    before: string;
+    after: string;
+    reason: string;
+}, {
+    itemId: string;
+    mutationId: string;
+    expectedSequence: number;
+    blockId: string;
+    before: string;
+    after: string;
+    reason?: string | undefined;
+}>;
+export type PagePatch = z.infer<typeof patchSchema>;
+export declare const scoped: (actor: ContentActor) => {
+    tenantId: string;
+    organizationId: string;
+};
+export declare const denied: () => ForbiddenException;

package/dist/domain.js

@@ -0,0 +1,23 @@
+import { z } from 'zod/v3';
+import { ForbiddenException } from '@nestjs/common';
+export const PLUGIN = '@xpert-ai/plugin-spaces';
+export const PROVIDER = 'spaces';
+export const VIEW = 'spaces.workspace';
+export const id = z.string().uuid();
+export const title = z.string().trim().min(1).max(200);
+export const actorSchema = z.object({ tenantId: id, organizationId: id, userId: id, assistantId: id.optional(), projectId: id.optional() });
+export const roleSchema = z.enum(['viewer', 'commenter', 'editor', 'manager', 'owner']);
+export const rank = { viewer: 1, commenter: 2, editor: 3, manager: 4, owner: 5 };
+export const required = { read: 1, comment: 2, write: 3, manage: 4 };
+export const kindSchema = z.enum(['folder', 'page', 'file', 'artifact']);
+export const blockSchema = z.object({
+    id, kind: z.enum(['paragraph', 'heading', 'code', 'bullet']), text: z.string().max(100000)
+}).strict();
+export const blocksSchema = z.array(blockSchema).min(1).max(1000);
+export const patchSchema = z.object({
+    itemId: id, mutationId: id, expectedSequence: z.number().int().nonnegative(),
+    blockId: id, before: z.string().max(100000), after: z.string().max(100000),
+    reason: z.string().max(2000).default('')
+}).strict();
+export const scoped = (actor) => ({ tenantId: actor.tenantId, organizationId: actor.organizationId });
+export const denied = () => new ForbiddenException('spaces.access_denied');

package/dist/editors.d.ts

@@ -0,0 +1,16 @@
+import { type RuntimeCapabilityRegistry } from '@xpert-ai/plugin-sdk';
+import { SpaceAccess } from './access.js';
+import { SpaceFiles } from './files.js';
+import { SpacesService } from './spaces.js';
+import { type SpaceActor } from './domain.js';
+/** Spaces creates navigation/resources; concrete models and editing belong to editor plugins. */
+export declare class SpaceEditors {
+    private readonly access;
+    private readonly files;
+    private readonly spaces;
+    private readonly runtime;
+    constructor(access: SpaceAccess, files: SpaceFiles, spaces: SpacesService, runtime: RuntimeCapabilityRegistry);
+    private scope;
+    list(actor: SpaceActor): Promise<import("@xpert-ai/contracts").FileContentEditorRegistration[]>;
+    create(actor: SpaceActor, spaceId: string, parentId: string | null, title: string, editorKey: string, buffer?: Buffer): Promise<import("./entities.js").SpaceItem>;
+}

package/dist/editors.js

@@ -0,0 +1,63 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from '@nestjs/common';
+import { ContentEditorsRuntimeCapability, XPERT_RUNTIME_CAPABILITIES_TOKEN } from '@xpert-ai/plugin-sdk';
+import { SpaceAccess } from './access.js';
+import { SpaceFiles } from './files.js';
+import { SpacesService } from './spaces.js';
+import { denied, scoped } from './domain.js';
+/** Spaces creates navigation/resources; concrete models and editing belong to editor plugins. */
+let SpaceEditors = class SpaceEditors {
+    access;
+    files;
+    spaces;
+    runtime;
+    constructor(access, files, spaces, runtime) {
+        this.access = access;
+        this.files = files;
+        this.spaces = spaces;
+        this.runtime = runtime;
+    }
+    scope(actor) {
+        if (!actor.projectId)
+            throw denied();
+        return { actor, projectId: actor.projectId, assistantId: actor.assistantId };
+    }
+    async list(actor) {
+        await this.access.project(actor);
+        return (await this.runtime.require(ContentEditorsRuntimeCapability).list(this.scope(actor))).filter(editor => editor.kind === 'file');
+    }
+    async create(actor, spaceId, parentId, title, editorKey, buffer) {
+        const access = await this.access.resource(actor, parentId ?? spaceId, 'write');
+        if (access.space.id !== spaceId)
+            throw denied();
+        const { registration, buffer: bytes } = await this.runtime.require(ContentEditorsRuntimeCapability).prepare({ ...this.scope(actor), editorKey, buffer });
+        const fileName = title.toLowerCase().endsWith(`.${registration.extension}`) ? title : `${title}.${registration.extension}`;
+        const item = await this.spaces.createItem(actor, { spaceId, parentId, title: fileName, kind: 'file' });
+        try {
+            await this.access.items.update({ ...scoped(actor), id: item.id }, { editorKey });
+            await this.files.put(actor, item.id, bytes, fileName, registration.mimeType);
+            return await this.access.items.findOneByOrFail({ ...scoped(actor), id: item.id });
+        }
+        catch (error) {
+            await this.access.items.update({ ...scoped(actor), id: item.id }, { deleted: true });
+            throw error;
+        }
+    }
+};
+SpaceEditors = __decorate([
+    Injectable(),
+    __param(3, Inject(XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [SpaceAccess, SpaceFiles, SpacesService, Object])
+], SpaceEditors);
+export { SpaceEditors };

package/dist/entities.d.ts

@@ -0,0 +1,68 @@
+import type { WorkspacePortableFileReference } from '@xpert-ai/plugin-sdk';
+import type { ItemKind } from './domain.js';
+export declare abstract class ScopedEntity {
+    id: string;
+    tenantId: string;
+    organizationId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare class Space extends ScopedEntity {
+    /** Storage and membership belong to this Project; Space only adds content metadata. */
+    projectId: string;
+    knowledgebaseId: string | null;
+    title: string;
+    ownerId: string;
+    visibility: 'personal' | 'team';
+    version: number;
+    deleted: boolean;
+}
+export declare class SpaceItem extends ScopedEntity {
+    /** Immutable import receipt; content stays in the project file. A copy does not inherit remote ACLs. */
+    importOrigin: {
+        provider: string;
+        documentId: string;
+        url: string | null;
+        revision: string;
+        contentHash: string;
+        format: 'text/plain';
+        importedAt: string;
+        warnings: string[];
+        bindingId: string;
+        requestHash: string;
+    } | null;
+    /** Logical page parent; parentId continues to mean the physical file folder. */
+    parentPageId: string | null;
+    /** Original request title makes a retried create idempotent even after a later rename. */
+    childRequestTitle: string | null;
+    filePath: string | null;
+    fileHash: string | null;
+    syncStatus: 'pending' | 'ready' | 'conflict' | 'failed';
+    syncError: string | null;
+    knowledgeDocumentId: string | null;
+    indexedHash: string | null;
+    indexStatus: 'pending' | 'processing' | 'ready' | 'failed';
+    indexError: string | null;
+    spaceId: string;
+    parentId: string | null;
+    createdById: string;
+    title: string;
+    kind: ItemKind;
+    version: number;
+    deleted: boolean;
+    projectedSequence: number;
+    markdown: string;
+    editorKey: string | null;
+    currentFileVersionId: string | null;
+    file: WorkspacePortableFileReference | null;
+    artifactId: string | null;
+    artifactVersionId: string | null;
+}
+export declare class SpaceFileVersion extends ScopedEntity {
+    itemId: string;
+    createdById: string;
+    reference: WorkspacePortableFileReference;
+    revisionId: string | null;
+    sha256: string;
+}
+export declare const entities: (typeof Space | typeof SpaceItem | typeof SpaceFileVersion)[];

package/dist/entities.js

@@ -0,0 +1,251 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Column, CreateDateColumn, Entity, Index, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+export class ScopedEntity {
+    id;
+    tenantId;
+    organizationId;
+    createdAt;
+    updatedAt;
+}
+__decorate([
+    PrimaryGeneratedColumn('uuid'),
+    __metadata("design:type", String)
+], ScopedEntity.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], ScopedEntity.prototype, "tenantId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], ScopedEntity.prototype, "organizationId", void 0);
+__decorate([
+    CreateDateColumn(),
+    __metadata("design:type", Date)
+], ScopedEntity.prototype, "createdAt", void 0);
+__decorate([
+    UpdateDateColumn(),
+    __metadata("design:type", Date)
+], ScopedEntity.prototype, "updatedAt", void 0);
+let Space = class Space extends ScopedEntity {
+    /** Storage and membership belong to this Project; Space only adds content metadata. */
+    projectId;
+    knowledgebaseId;
+    title;
+    ownerId;
+    visibility;
+    version;
+    deleted;
+};
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], Space.prototype, "projectId", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], Space.prototype, "knowledgebaseId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 200 }),
+    __metadata("design:type", String)
+], Space.prototype, "title", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], Space.prototype, "ownerId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 20 }),
+    __metadata("design:type", String)
+], Space.prototype, "visibility", void 0);
+__decorate([
+    Column({ type: 'int', default: 1 }),
+    __metadata("design:type", Number)
+], Space.prototype, "version", void 0);
+__decorate([
+    Column({ type: 'boolean', default: false }),
+    __metadata("design:type", Boolean)
+], Space.prototype, "deleted", void 0);
+Space = __decorate([
+    Entity('plugin_spaces_space'),
+    Index(['tenantId', 'organizationId']),
+    Index('IDX_space_project', ['tenantId', 'organizationId', 'projectId'], { unique: true })
+], Space);
+export { Space };
+let SpaceItem = class SpaceItem extends ScopedEntity {
+    /** Immutable import receipt; content stays in the project file. A copy does not inherit remote ACLs. */
+    importOrigin;
+    /** Logical page parent; parentId continues to mean the physical file folder. */
+    parentPageId;
+    /** Original request title makes a retried create idempotent even after a later rename. */
+    childRequestTitle;
+    filePath;
+    fileHash;
+    syncStatus;
+    syncError;
+    knowledgeDocumentId;
+    indexedHash;
+    indexStatus;
+    indexError;
+    spaceId;
+    parentId;
+    createdById;
+    title;
+    kind;
+    version;
+    deleted;
+    projectedSequence;
+    markdown;
+    editorKey;
+    currentFileVersionId;
+    file;
+    artifactId;
+    artifactVersionId;
+};
+__decorate([
+    Column({ type: 'jsonb', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "importOrigin", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "parentPageId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 200, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "childRequestTitle", void 0);
+__decorate([
+    Column({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "filePath", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 64, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "fileHash", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 24, default: 'pending' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "syncStatus", void 0);
+__decorate([
+    Column({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "syncError", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "knowledgeDocumentId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 64, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "indexedHash", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 24, default: 'pending' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "indexStatus", void 0);
+__decorate([
+    Column({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "indexError", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "spaceId", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "parentId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "createdById", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 200 }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "title", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 20 }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "kind", void 0);
+__decorate([
+    Column({ type: 'int', default: 1 }),
+    __metadata("design:type", Number)
+], SpaceItem.prototype, "version", void 0);
+__decorate([
+    Column({ type: 'boolean', default: false }),
+    __metadata("design:type", Boolean)
+], SpaceItem.prototype, "deleted", void 0);
+__decorate([
+    Column({ type: 'int', default: -1 }),
+    __metadata("design:type", Number)
+], SpaceItem.prototype, "projectedSequence", void 0);
+__decorate([
+    Column({ type: 'text', default: '' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "markdown", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 100, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "editorKey", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "currentFileVersionId", void 0);
+__decorate([
+    Column({ type: 'jsonb', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "file", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "artifactId", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "artifactVersionId", void 0);
+SpaceItem = __decorate([
+    Entity('plugin_spaces_item'),
+    Index(['tenantId', 'organizationId', 'spaceId']),
+    Index('IDX_space_page_parent', ['tenantId', 'organizationId', 'spaceId', 'parentPageId']),
+    Index('IDX_space_item_active_path', ['spaceId', 'filePath'], { unique: true, where: '"deleted" = false AND "filePath" IS NOT NULL' })
+], SpaceItem);
+export { SpaceItem };
+let SpaceFileVersion = class SpaceFileVersion extends ScopedEntity {
+    itemId;
+    createdById;
+    reference;
+    revisionId;
+    sha256;
+};
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceFileVersion.prototype, "itemId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceFileVersion.prototype, "createdById", void 0);
+__decorate([
+    Column({ type: 'jsonb' }),
+    __metadata("design:type", Object)
+], SpaceFileVersion.prototype, "reference", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceFileVersion.prototype, "revisionId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 64 }),
+    __metadata("design:type", String)
+], SpaceFileVersion.prototype, "sha256", void 0);
+SpaceFileVersion = __decorate([
+    Entity('plugin_spaces_file_version'),
+    Index(['tenantId', 'organizationId', 'itemId'])
+], SpaceFileVersion);
+export { SpaceFileVersion };
+export const entities = [Space, SpaceItem, SpaceFileVersion];