@interactive-inc/docs-client 0.0.4 → 0.0.5

package/build/values/doc-schema-value.d.ts

@@ -0,0 +1,99 @@
+import type { DocFileMdFrontMatter, DocRelationFile, DocSchemaRecord } from "../types";
+import { DocSchemaFieldRelationMultipleValue } from "./doc-schema-field-relation-multiple-value";
+import { DocSchemaFieldRelationSingleValue } from "./doc-schema-field-relation-single-value";
+import type { DocSchemaFieldValue } from "./doc-schema-field-value";
+/**
+ * スキーマとリレーション
+ */
+export declare class DocSchemaValue {
+    readonly value: DocSchemaRecord;
+    constructor(value: DocSchemaRecord);
+    /**
+     * フィールド名の一覧を取得
+     */
+    get fieldNames(): string[];
+    /**
+     * 指定されたフィールド名のフィールドを取得
+     */
+    field(name: string): DocSchemaFieldValue | null;
+    get fields(): DocSchemaFieldValue[];
+    get relationFields(): (DocSchemaFieldRelationSingleValue | DocSchemaFieldRelationMultipleValue)[];
+    /**
+     * 空のスキーマエンティティを作成
+     */
+    static empty(): DocSchemaValue;
+    /**
+     * スキーマからリレーションパスを抽出
+     */
+    extractRelationPaths(): Set<string>;
+    /**
+     * フィールドがリレーション型かどうかを判定
+     */
+    private isRelationField;
+    /**
+     * リレーションオプションを作成
+     */
+    createRelationOption(filePath: string, title: string | null): DocRelationFile;
+    /**
+     * ファイルをスキップすべきかどうかを判定
+     */
+    shouldSkipFile(filePath: string): boolean;
+    /**
+     * 値を指定された型に変換する（デフォルト値フォールバック付き）
+     */
+    convertValue(value: unknown, targetType: string, defaultValue: unknown): unknown;
+    /**
+     * 型別の変換処理
+     */
+    private convertByType;
+    /**
+     * 文字列型への変換
+     */
+    private convertToString;
+    /**
+     * 数値型への変換
+     */
+    private convertToNumber;
+    /**
+     * ブール型への変換
+     */
+    private convertToBoolean;
+    /**
+     * 配列型への変換
+     */
+    private convertToArray;
+    /**
+     * リレーション型への変換
+     */
+    private convertToRelation;
+    /**
+     * マルチリレーション型への変換
+     */
+    private convertToMultiRelation;
+    /**
+     * パスからファイル名を抽出（拡張子除去）
+     */
+    private extractFileNameFromPath;
+    /**
+     * スキーマベースでFrontMatterを補完する
+     */
+    getCompleteFrontMatter(rawFrontMatter: unknown): DocFileMdFrontMatter;
+    /**
+     * スキーマからデフォルトFrontMatterを生成
+     */
+    private generateDefaultFrontMatter;
+    /**
+     * 既存の値を保持しながらマージ
+     */
+    private mergePreservingExistingValues;
+    /**
+     * ファイルパスからファイル名を抽出（拡張子なし）
+     */
+    private extractFileName;
+    /**
+     * nullまundefinedのチェック
+     */
+    private isNullOrUndefined;
+    toJson(): DocSchemaRecord;
+}
+//# sourceMappingURL=doc-schema-value.d.ts.map

package/build/values/doc-schema-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-schema-value.d.ts","sourceRoot":"","sources":["../../lib/values/doc-schema-value.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EAEf,eAAe,EAEhB,MAAM,UAAU,CAAA;AAGjB,OAAO,EAAE,mCAAmC,EAAE,MAAM,4CAA4C,CAAA;AAChG,OAAO,EAAE,iCAAiC,EAAE,MAAM,0CAA0C,CAAA;AAC5F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAEnE;;GAEG;AACH,qBAAa,cAAc;IACb,QAAQ,CAAC,KAAK,EAAE,eAAe;IAA3C,YAAqB,KAAK,EAAE,eAAe,EAI1C;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,EAAE,CAEzB;IAED;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAU9C;IAED,IAAI,MAAM,0BAUT;IAED,IAAI,cAAc,IAAI,CAClB,iCAAiC,GACjC,mCAAmC,CACtC,EAAE,CAOF;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,IAAI,cAAc,CAE7B;IAED;;OAEG;IACH,oBAAoB,IAAI,GAAG,CAAC,MAAM,CAAC,CAYlC;IAED;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,oBAAoB,CAClB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,eAAe,CAQjB;IAED;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAExC;IAED;;OAEG;IACH,YAAY,CACV,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,OAAO,GACpB,OAAO,CAUT;IAED;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAK/B;;OAEG;IACH,sBAAsB,CAAC,cAAc,EAAE,OAAO,GAAG,oBAAoB,CAMpE;IAED;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAalC;;OAEG;IACH,OAAO,CAAC,6BAA6B;IAkBrC;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB,MAAM,IAAI,eAAe,CAExB;CACF"}

package/build/values/doc-schema-value.js

@@ -0,0 +1,269 @@
+import { zDocFileMdFrontMatter, zDocRelationFile, zDocSchema } from "../models";
+import { DocFrontMatterMdValue } from "./doc-front-matter-md-value";
+import { DocSchemaFieldFactory } from "./doc-schema-field-factory";
+import { DocSchemaFieldRelationMultipleValue } from "./doc-schema-field-relation-multiple-value";
+import { DocSchemaFieldRelationSingleValue } from "./doc-schema-field-relation-single-value";
+/**
+ * スキーマとリレーション
+ */
+export class DocSchemaValue {
+    value;
+    constructor(value) {
+        this.value = value;
+        zDocSchema.parse(value);
+        Object.freeze(this.value);
+        Object.freeze(this);
+    }
+    /**
+     * フィールド名の一覧を取得
+     */
+    get fieldNames() {
+        return Object.keys(this.value);
+    }
+    /**
+     * 指定されたフィールド名のフィールドを取得
+     */
+    field(name) {
+        const fieldDef = this.value[name];
+        if (fieldDef === undefined) {
+            return null;
+        }
+        const factory = new DocSchemaFieldFactory();
+        return factory.fromSchemaEntry(name, fieldDef);
+    }
+    get fields() {
+        const factory = new DocSchemaFieldFactory();
+        return this.fieldNames.map((name) => {
+            const fieldValue = this.value[name];
+            if (!fieldValue) {
+                throw new Error(`Field ${name} not found in schema`);
+            }
+            return factory.fromSchemaEntry(name, fieldValue);
+        });
+    }
+    get relationFields() {
+        return this.fields.filter((t) => {
+            return (t instanceof DocSchemaFieldRelationSingleValue ||
+                t instanceof DocSchemaFieldRelationMultipleValue);
+        });
+    }
+    /**
+     * 空のスキーマエンティティを作成
+     */
+    static empty() {
+        return new DocSchemaValue({});
+    }
+    /**
+     * スキーマからリレーションパスを抽出
+     */
+    extractRelationPaths() {
+        if (!this.value)
+            return new Set();
+        const uniqueRelationPaths = new Set();
+        for (const field of Object.values(this.value)) {
+            if (this.isRelationField(field) && "path" in field) {
+                uniqueRelationPaths.add(field.path);
+            }
+        }
+        return uniqueRelationPaths;
+    }
+    /**
+     * フィールドがリレーション型かどうかを判定
+     */
+    isRelationField(field) {
+        return field.type === "relation" || field.type === "multi-relation";
+    }
+    /**
+     * リレーションオプションを作成
+     */
+    createRelationOption(filePath, title) {
+        const fileName = this.extractFileName(filePath);
+        return zDocRelationFile.parse({
+            name: fileName,
+            label: title || fileName,
+            value: fileName,
+            path: filePath,
+        });
+    }
+    /**
+     * ファイルをスキップすべきかどうかを判定
+     */
+    shouldSkipFile(filePath) {
+        return filePath.endsWith("index.md") || filePath.endsWith("README.md");
+    }
+    /**
+     * 値を指定された型に変換する（デフォルト値フォールバック付き）
+     */
+    convertValue(value, targetType, defaultValue) {
+        if (this.isNullOrUndefined(value)) {
+            return defaultValue;
+        }
+        try {
+            return this.convertByType(value, targetType, defaultValue);
+        }
+        catch {
+            return defaultValue;
+        }
+    }
+    /**
+     * 型別の変換処理
+     */
+    convertByType(value, targetType, defaultValue) {
+        if (targetType === "text") {
+            return this.convertToString(value, defaultValue);
+        }
+        if (targetType === "number") {
+            return this.convertToNumber(value, defaultValue);
+        }
+        if (targetType === "boolean") {
+            return this.convertToBoolean(value, defaultValue);
+        }
+        if (targetType === "multi-text" || targetType === "array") {
+            return this.convertToArray(value, defaultValue);
+        }
+        if (targetType === "relation") {
+            return this.convertToRelation(value, defaultValue);
+        }
+        if (targetType === "multi-relation") {
+            return this.convertToMultiRelation(value, defaultValue);
+        }
+        return defaultValue;
+    }
+    /**
+     * 文字列型への変換
+     */
+    convertToString(value, defaultValue) {
+        if (typeof value === "string")
+            return value;
+        if (typeof value === "number")
+            return String(value);
+        if (typeof value === "boolean")
+            return String(value);
+        return defaultValue;
+    }
+    /**
+     * 数値型への変換
+     */
+    convertToNumber(value, defaultValue) {
+        if (typeof value === "number")
+            return value;
+        if (typeof value === "string") {
+            const parsed = Number(value);
+            return Number.isNaN(parsed) ? defaultValue : parsed;
+        }
+        if (typeof value === "boolean")
+            return value ? 1 : 0;
+        return defaultValue;
+    }
+    /**
+     * ブール型への変換
+     */
+    convertToBoolean(value, defaultValue) {
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "string") {
+            const lower = value.toLowerCase();
+            if (lower === "true" || lower === "1")
+                return true;
+            if (lower === "false" || lower === "0")
+                return false;
+            return defaultValue;
+        }
+        if (typeof value === "number")
+            return value !== 0;
+        return defaultValue;
+    }
+    /**
+     * 配列型への変換
+     */
+    convertToArray(value, defaultValue) {
+        if (Array.isArray(value))
+            return value;
+        if (typeof value === "string") {
+            return value.split(",").map((item) => item.trim());
+        }
+        return defaultValue;
+    }
+    /**
+     * リレーション型への変換
+     */
+    convertToRelation(value, defaultValue) {
+        if (typeof value === "string") {
+            return this.extractFileNameFromPath(value);
+        }
+        return defaultValue;
+    }
+    /**
+     * マルチリレーション型への変換
+     */
+    convertToMultiRelation(value, defaultValue) {
+        if (Array.isArray(value)) {
+            return value
+                .filter((item) => typeof item === "string")
+                .map((item) => this.extractFileNameFromPath(item));
+        }
+        if (typeof value === "string") {
+            return value
+                .split(",")
+                .map((item) => this.extractFileNameFromPath(item.trim()));
+        }
+        return defaultValue;
+    }
+    /**
+     * パスからファイル名を抽出（拡張子除去）
+     */
+    extractFileNameFromPath(path) {
+        const fileName = path.split("/").pop() || path;
+        return fileName.replace(/\.md$/, "");
+    }
+    /**
+     * スキーマベースでFrontMatterを補完する
+     */
+    getCompleteFrontMatter(rawFrontMatter) {
+        const defaultFrontMatter = this.generateDefaultFrontMatter();
+        return this.mergePreservingExistingValues(defaultFrontMatter, rawFrontMatter);
+    }
+    /**
+     * スキーマからデフォルトFrontMatterを生成
+     */
+    generateDefaultFrontMatter() {
+        if (!this.value)
+            return {};
+        const defaultFrontMatter = {};
+        for (const [key, field] of Object.entries(this.value)) {
+            defaultFrontMatter[key] =
+                DocFrontMatterMdValue.generateDefaultValueFromSchemaField(field);
+        }
+        return zDocFileMdFrontMatter.parse(defaultFrontMatter);
+    }
+    /**
+     * 既存の値を保持しながらマージ
+     */
+    mergePreservingExistingValues(defaults, existing) {
+        const result = { ...defaults };
+        if (existing && typeof existing === "object") {
+            const validatedData = zDocFileMdFrontMatter.parse(existing);
+            for (const [key, value] of Object.entries(validatedData)) {
+                if (value !== undefined && value !== null) {
+                    result[key] = value;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * ファイルパスからファイル名を抽出（拡張子なし）
+     */
+    extractFileName(filePath) {
+        return filePath.split("/").pop()?.replace(".md", "") || filePath;
+    }
+    /**
+     * nullまundefinedのチェック
+     */
+    isNullOrUndefined(value) {
+        return value === null || value === undefined;
+    }
+    toJson() {
+        return this.value;
+    }
+}

package/build/values/doc-schema-value.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=doc-schema-value.test.d.ts.map

package/build/values/doc-schema-value.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-schema-value.test.d.ts","sourceRoot":"","sources":["../../lib/values/doc-schema-value.test.ts"],"names":[],"mappings":""}

package/build/values/doc-schema-value.test.js

@@ -0,0 +1,301 @@
+import { expect, test } from "bun:test";
+import { DocSchemaFieldRelationMultipleValue } from "./doc-schema-field-relation-multiple-value";
+import { DocSchemaFieldRelationSingleValue } from "./doc-schema-field-relation-single-value";
+import { DocSchemaFieldTextSingleValue } from "./doc-schema-field-text-single-value";
+import { DocSchemaValue } from "./doc-schema-value";
+test("スキーマの基本プロパティを取得できる", () => {
+    const schema = new DocSchemaValue({
+        title: {
+            type: "text",
+            required: true,
+            title: null,
+            description: null,
+            default: null,
+        },
+        author: {
+            type: "relation",
+            required: false,
+            path: "users/authors",
+            title: null,
+            description: null,
+            default: null,
+        },
+    });
+    expect(schema.fieldNames).toEqual(["title", "author"]);
+});
+test("フィールドを名前で取得できる", () => {
+    const schema = new DocSchemaValue({
+        title: {
+            type: "text",
+            required: true,
+            title: "タイトル",
+            description: null,
+            default: null,
+        },
+    });
+    const field = schema.field("title");
+    expect(field).toBeInstanceOf(DocSchemaFieldTextSingleValue);
+    expect(field?.key).toBe("title");
+    expect(field?.title).toBe("タイトル");
+});
+test("存在しないフィールドの場合nullを返す", () => {
+    const schema = new DocSchemaValue({});
+    expect(schema.field("nonexistent")).toBeNull();
+});
+test("全フィールドを取得できる", () => {
+    const schema = new DocSchemaValue({
+        title: {
+            type: "text",
+            required: true,
+            title: null,
+            description: null,
+            default: null,
+        },
+        price: {
+            type: "number",
+            required: false,
+            title: null,
+            description: null,
+            default: null,
+        },
+        published: {
+            type: "boolean",
+            required: true,
+            title: null,
+            description: null,
+            default: null,
+        },
+    });
+    const fields = schema.fields;
+    expect(fields.length).toBe(3);
+    expect(fields[0].key).toBe("title");
+    expect(fields[1].key).toBe("price");
+    expect(fields[2].key).toBe("published");
+});
+test("リレーションフィールドのみを取得できる", () => {
+    const schema = new DocSchemaValue({
+        title: {
+            type: "text",
+            required: true,
+            title: null,
+            description: null,
+            default: null,
+        },
+        author: {
+            type: "relation",
+            required: false,
+            path: "users/authors",
+            title: null,
+            description: null,
+            default: null,
+        },
+        tags: {
+            type: "multi-relation",
+            required: false,
+            path: "metadata/tags",
+            title: null,
+            description: null,
+            default: null,
+        },
+        description: {
+            type: "text",
+            required: false,
+            title: null,
+            description: null,
+            default: null,
+        },
+    });
+    const relationFields = schema.relationFields;
+    expect(relationFields.length).toBe(2);
+    expect(relationFields[0]).toBeInstanceOf(DocSchemaFieldRelationSingleValue);
+    expect(relationFields[1]).toBeInstanceOf(DocSchemaFieldRelationMultipleValue);
+});
+test("空のスキーマを作成できる", () => {
+    const schema = DocSchemaValue.empty();
+    expect(schema.fieldNames).toEqual([]);
+    expect(schema.fields).toEqual([]);
+});
+test("リレーションパスを抽出できる", () => {
+    const schema = new DocSchemaValue({
+        author: {
+            type: "relation",
+            required: false,
+            path: "users/authors",
+            title: null,
+            description: null,
+            default: null,
+        },
+        category: {
+            type: "relation",
+            required: false,
+            path: "categories",
+            title: null,
+            description: null,
+            default: null,
+        },
+        tags: {
+            type: "multi-relation",
+            required: false,
+            path: "metadata/tags",
+            title: null,
+            description: null,
+            default: null,
+        },
+        title: {
+            type: "text",
+            required: true,
+            title: null,
+            description: null,
+            default: null,
+        },
+    });
+    const paths = schema.extractRelationPaths();
+    expect(paths.size).toBe(3);
+    expect(paths.has("users/authors")).toBe(true);
+    expect(paths.has("categories")).toBe(true);
+    expect(paths.has("metadata/tags")).toBe(true);
+});
+test("リレーションオプションを作成できる", () => {
+    const schema = new DocSchemaValue({});
+    const option = schema.createRelationOption("users/tanaka.md", "田中太郎");
+    expect(option.value).toBe("tanaka");
+    expect(option.label).toBe("田中太郎");
+    expect(option.path).toBe("users/tanaka.md");
+});
+test("タイトルがnullの場合ファイル名をラベルとして使用する", () => {
+    const schema = new DocSchemaValue({});
+    const option = schema.createRelationOption("categories/tech.md", null);
+    expect(option.value).toBe("tech");
+    expect(option.label).toBe("tech");
+});
+test("ファイルをスキップすべきか判定できる", () => {
+    const schema = new DocSchemaValue({});
+    expect(schema.shouldSkipFile("docs/index.md")).toBe(true);
+    expect(schema.shouldSkipFile("docs/README.md")).toBe(true);
+    expect(schema.shouldSkipFile("docs/article.md")).toBe(false);
+});
+test("値を指定された型に変換できる", () => {
+    const schema = new DocSchemaValue({});
+    // テキスト型への変換
+    expect(schema.convertValue(123, "text", "default")).toBe("123");
+    expect(schema.convertValue(true, "text", "default")).toBe("true");
+    expect(schema.convertValue(null, "text", "default")).toBe("default");
+    // 数値型への変換
+    expect(schema.convertValue("123", "number", 0)).toBe(123);
+    expect(schema.convertValue(true, "number", 0)).toBe(1);
+    expect(schema.convertValue(false, "number", 0)).toBe(0);
+    expect(schema.convertValue("invalid", "number", 0)).toBe(0);
+    // ブール型への変換
+    expect(schema.convertValue("true", "boolean", false)).toBe(true);
+    expect(schema.convertValue("1", "boolean", false)).toBe(true);
+    expect(schema.convertValue("false", "boolean", false)).toBe(false);
+    expect(schema.convertValue(0, "boolean", false)).toBe(false);
+    expect(schema.convertValue(1, "boolean", false)).toBe(true);
+    // 配列型への変換
+    expect(schema.convertValue("a,b,c", "multi-text", [])).toEqual([
+        "a",
+        "b",
+        "c",
+    ]);
+    expect(schema.convertValue(["x", "y"], "array", [])).toEqual(["x", "y"]);
+    // リレーション型への変換
+    expect(schema.convertValue("users/tanaka.md", "relation", "")).toBe("tanaka");
+    expect(schema.convertValue("tanaka", "relation", "")).toBe("tanaka");
+    // マルチリレーション型への変換
+    expect(schema.convertValue("a.md,b.md", "multi-relation", [])).toEqual([
+        "a",
+        "b",
+    ]);
+    expect(schema.convertValue(["x.md", "y.md"], "multi-relation", [])).toEqual([
+        "x",
+        "y",
+    ]);
+});
+test("スキーマベースでFrontMatterを補完できる", () => {
+    const schema = new DocSchemaValue({
+        title: {
+            type: "text",
+            required: true,
+            default: "無題",
+            title: null,
+            description: null,
+        },
+        published: {
+            type: "boolean",
+            required: false,
+            default: false,
+            title: null,
+            description: null,
+        },
+        tags: {
+            type: "multi-text",
+            required: false,
+            default: [],
+            title: null,
+            description: null,
+        },
+    });
+    const result = schema.getCompleteFrontMatter({
+        title: "記事タイトル",
+    });
+    expect(result).toEqual({
+        title: "記事タイトル",
+        published: false,
+        tags: [],
+    });
+});
+test("既存の値を保持しながらデフォルト値を補完する", () => {
+    const schema = new DocSchemaValue({
+        title: {
+            type: "text",
+            required: true,
+            default: "無題",
+            title: null,
+            description: null,
+        },
+        author: {
+            type: "text",
+            required: false,
+            default: "匿名",
+            title: null,
+            description: null,
+        },
+        published: {
+            type: "boolean",
+            required: false,
+            default: false,
+            title: null,
+            description: null,
+        },
+    });
+    const result = schema.getCompleteFrontMatter({
+        author: "田中太郎",
+        published: true,
+    });
+    expect(result).toEqual({
+        title: "無題",
+        author: "田中太郎",
+        published: true,
+    });
+});
+test("JSON形式に変換できる", () => {
+    const schemaData = {
+        field1: {
+            type: "text",
+            required: true,
+            title: null,
+            description: null,
+            default: null,
+        },
+        field2: {
+            type: "number",
+            required: false,
+            title: null,
+            description: null,
+            default: null,
+        },
+    };
+    const schema = new DocSchemaValue(schemaData);
+    const json = schema.toJson();
+    expect(json).toEqual(schemaData);
+});