@pylonts/dsl 1.1.1 → 1.1.2

package/dist/action.d.ts

@@ -0,0 +1,7 @@
+import { SchemaBase } from './dsl.js';
+/** An action a user can perform on a page (e.g. submit, approve, reject).
+ *  Subclasses use `type` as the discriminator. */
+export interface ActionSchema extends SchemaBase {
+    type: string;
+}
+export declare function defineAction(name: string, description?: string): ActionSchema;

package/dist/action.js

@@ -0,0 +1,3 @@
+export function defineAction(name, description) {
+    return { name, description, type: 'gesture' };
+}

package/dist/asset.d.ts

@@ -15,8 +15,8 @@
  *   });
  *
  *   // CLI:
- *   // gen-cli asset list --tag form       → all form-related assets
- *   // gen-cli asset import formatAmt      → import { formatAmt } from '@/utils/amount';
+ *   // pylonts gen asset list --tag form       → all form-related assets
+ *   // pylonts gen asset import formatAmt      → import { formatAmt } from '@/utils/amount';
  */
 export type AssetCategory = 'util' | 'component' | 'flow' | 'page' | 'hook';
 export interface AssetImport {

package/dist/asset.js

@@ -15,8 +15,8 @@
  *   });
  *
  *   // CLI:
- *   // gen-cli asset list --tag form       → all form-related assets
- *   // gen-cli asset import formatAmt      → import { formatAmt } from '@/utils/amount';
+ *   // pylonts gen asset list --tag form       → all form-related assets
+ *   // pylonts gen asset import formatAmt      → import { formatAmt } from '@/utils/amount';
  */
 export function defineAsset(config) {
     return {

package/dist/component.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaBase } from './dsl.js';
+import type { RefSchema } from './ref.js';
+import type { ActionSchema } from './action.js';
+import type { EventDataSchema } from './event.js';
+/** A component event trigger declaration. */
+export interface TriggerSchema extends SchemaBase {
+    /** Data the event carries (e.g. e.detail). */
+    eventData?: EventDataSchema;
+    /** Actions that fire when the event occurs. */
+    actions?: ActionSchema[];
+}
+/** A UI component declaration — a virtual schema that describes props and
+ *  event triggers, not a real renderable component.
+ *
+ *  properties: data bindings via RefSchema (or literal values).
+ *  triggers: event name → TriggerSchema bindings. */
+export interface ComponentSchema extends SchemaBase {
+    properties: Record<string, RefSchema | string | number | boolean>;
+    triggers: Record<string, TriggerSchema>;
+}

package/dist/component.js

@@ -0,0 +1 @@
+export {};

package/dist/convert.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaBase } from './dsl.js';
+/** Declares post-call result → page data field mapping.
+ *  Driver generates per-item transform (e.g. .map()) before setData. */
+export interface ConvertSchema extends SchemaBase {
+    type: 'convert';
+    /** { targetField: sourceField } — renames or copies fields from call result. */
+    fields: Record<string, string>;
+}
+export declare function defineConvert(name: string, fields: Record<string, string>): ConvertSchema;

package/dist/convert.js

@@ -0,0 +1,3 @@
+export function defineConvert(name, fields) {
+    return { name, type: 'convert', fields };
+}

package/dist/curd.d.ts

@@ -1,12 +1,14 @@
 import { SchemaBase, Field, Operator } from './dsl.js';
 import { TableSchema } from './db.js';
 import { FrontAppSchema } from './project.js';
-import { ActionSchema } from './page.js';
+import { ActionSchema } from './action.js';
 /** Mode of an action page: modal dialog or standalone route. */
 export type ActionPageMode = 'modal' | 'route';
 /** One CRUD action page (add / update / detail). */
 export interface ActionPage {
     mode: ActionPageMode;
+    /** For add/update: when true, render as modal on list page; when false/undefined, render as standalone route page. */
+    modal?: boolean;
     /** Fields rendered on this page. Required, non-empty — every field the
      *  frontend shows must be listed explicitly. */
     columns: Field[];

package/dist/db.d.ts

@@ -15,6 +15,8 @@ export interface TableSchemaOptions<N extends string = string, C extends Record<
     actor?: boolean;
     generator?: string;
     autoIncrement?: Field;
+    /** 本表用于关联显示的名称字段（如 name / username）。被外键引用时，自动用该字段做 label 展示。 */
+    label?: Field;
     primaryKey?: Field | Field[];
     indexes?: Index[];
     foreignKeys?: Record<string, ForeignKey>;
@@ -40,6 +42,8 @@ export declare class TableSchema<N extends string = string, C extends Record<str
     indexes?: Index[];
     /** 外键，引用其他表的字段 */
     foreignKeys?: Record<string, ForeignKey>;
+    /** 本表用于关联显示的名称字段（如 name / username）。被外键引用时，自动用该字段做 label 展示。 */
+    label?: Field;
     /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
     phrase?: EntityPhrase;
     /** 本表引用的所有枚举定义（map，key 为枚举标识），显式声明供 gen-enums 收集 */

package/dist/db.js

@@ -16,6 +16,8 @@ export class TableSchema {
     indexes;
     /** 外键，引用其他表的字段 */
     foreignKeys;
+    /** 本表用于关联显示的名称字段（如 name / username）。被外键引用时，自动用该字段做 label 展示。 */
+    label;
     /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
     phrase;
     /** 本表引用的所有枚举定义（map，key 为枚举标识），显式声明供 gen-enums 收集 */
@@ -34,6 +36,7 @@ export class TableSchema {
         this.primaryKey = options.primaryKey;
         this.indexes = options.indexes;
         this.foreignKeys = options.foreignKeys;
+        this.label = options.label;
         this.phrase = options.phrase;
         this.enums = options.enums;
         this.columns = options.columns;
@@ -49,6 +52,12 @@ export class TableSchema {
 }
 export function defineTable(name, schema) {
     const table = new TableSchema(name, schema);
+    if (table.generator && table.autoIncrement) {
+        throw new Error(`table '${name}': generator and autoIncrement are mutually exclusive`);
+    }
+    if (table.label && !Object.values(table.columns).includes(table.label)) {
+        throw new Error(`table '${name}': label field '${table.label.name}' must be one of the table's columns`);
+    }
     for (const key of Object.keys(table.columns)) {
         const field = table.columns[key];
         if (field.schema && field.schema !== table) {

package/dist/dsl.d.ts

@@ -1,3 +1,4 @@
+import type { ImportBase } from './import-base.js';
 import type { MockDescriptor } from './mock.js';
 /** Field query comparison operators (search field semantics). */
 export type Operator = 'eq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ne';
@@ -5,6 +6,10 @@ export interface SchemaBase {
     name: string;
     description?: string;
 }
+/** Schema base for cross-file entities. importRef locates the generating module; inline schemas omit it. */
+export interface ImportableSchemaBase extends SchemaBase {
+    importRef?: ImportBase;
+}
 /** Field collection schemas (DB table vs DTO message); `type` is the discriminator */
 export interface CollectionSchemaBase extends SchemaBase {
     type: string;

package/dist/dto.d.ts

@@ -38,8 +38,8 @@ export declare class DtoField implements SchemaBase {
     name: string;
     /** 字段描述 */
     description?: string;
-    /** 所属 DTO 容器（buildMessage 反写） */
-    schema?: DtoMessage;
+    /** 所属容器（buildMessage / defineRouteData / definePageData 反写） */
+    schema?: CollectionSchemaBase;
     field: Field | DtoArrayFieldDef | DtoObjectFieldDef;
     pattern?: string;
     optional?: boolean;

package/dist/dto.js

@@ -5,7 +5,7 @@ export class DtoField {
     name;
     /** 字段描述 */
     description;
-    /** 所属 DTO 容器（buildMessage 反写） */
+    /** 所属容器（buildMessage / defineRouteData / definePageData 反写） */
     schema;
     field;
     pattern;

package/dist/event.d.ts

@@ -0,0 +1,8 @@
+import type { CollectionSchemaBase } from './dsl.js';
+import type { DtoField } from './dto.js';
+/** Data carried by a component event (e.g. e.detail from a Tab onChange). */
+export interface EventDataSchema extends CollectionSchemaBase {
+    type: 'event';
+    fields: Record<string, DtoField>;
+}
+export declare function defineEventData(name: string, fields: Record<string, DtoField>): EventDataSchema;

package/dist/event.js

@@ -0,0 +1,3 @@
+export function defineEventData(name, fields) {
+    return { name, type: 'event', fields };
+}

package/dist/index.d.ts

@@ -15,7 +15,17 @@ export * from './typebox-driver.js';
 export * from './pattern.js';
 export * from './patterns/retry.js';
 export * from './flow.js';
+export * from './action.js';
+export * from './event.js';
+export * from './component.js';
+export * from './convert.js';
+export * from './ref.js';
+export * from './route.js';
 export * from './page.js';
 export * from './curd.js';
 export * from './page-flow.js';
+export * from './provider.js';
+export * from './page-def.js';
 export * from './mermaid-driver.js';
+export * from './navigation.js';
+export * from './popup.js';

package/dist/index.js

@@ -15,7 +15,17 @@ export * from './typebox-driver.js';
 export * from './pattern.js';
 export * from './patterns/retry.js';
 export * from './flow.js';
+export * from './action.js';
+export * from './event.js';
+export * from './component.js';
+export * from './convert.js';
+export * from './ref.js';
+export * from './route.js';
 export * from './page.js';
 export * from './curd.js';
 export * from './page-flow.js';
+export * from './provider.js';
+export * from './page-def.js';
 export * from './mermaid-driver.js';
+export * from './navigation.js';
+export * from './popup.js';

package/dist/mermaid-driver.js

@@ -56,7 +56,8 @@ export function renderPageFlowMermaid(schema) {
         lines.push(`    subgraph app${appIdx}["${escapeLabel(appName)}"]`);
         pages.forEach((p, i) => ids.set(p, `app${appIdx}_p${i}`));
         for (const p of pages) {
-            lines.push(`    ${ids.get(p)}["${escapeLabel(p.name)}"]`);
+            const display = p.label ?? p.name;
+            lines.push(`    ${ids.get(p)}["${escapeLabel(display)}"]`);
         }
         appIdx++;
         lines.push('    end');

package/dist/mock.d.ts

@@ -1,6 +1,6 @@
 /**
- * Pure-data mock descriptor. Stored on DTO fields, consumed by gen-cli mock
- * or runtime resolveMock. No function references — serializable and gen-readable.
+ * Pure-data mock descriptor. Stored on DTO fields, consumed by pylonts lint mock
+ * or MockRegistry.resolve. No function references — serializable and gen-readable.
  *
  * @example { fn: 'abc', count: 20 }
  * @example { fn: 'amt', min: 10, max: 500 }
@@ -8,23 +8,5 @@
  */
 export interface MockDescriptor {
     fn: string;
-    [param: string]: unknown;
+    [args: string]: unknown;
 }
-/**
- * Result of a descriptor factory call: pure-data descriptor + lazy generator.
- * generate is non-enumerable — JSON.stringify / spread won't pick it up.
- */
-export interface MockSchema {
-    descriptor: MockDescriptor;
-    generate: () => unknown;
-}
-type Params = Record<string, unknown>;
-/**
- * Define a mock descriptor factory.
- *
- * @param fn      mock function name (for descriptor & dispatch)
- * @param resolve converts descriptor params to a no-arg generator
- * @returns       (params?) => { descriptor, generate }
- */
-export declare function defineMock(fn: string, resolve: (d: Params) => () => unknown): (params?: Params) => MockSchema;
-export {};

package/dist/mock.js

@@ -1,18 +1 @@
-/**
- * Define a mock descriptor factory.
- *
- * @param fn      mock function name (for descriptor & dispatch)
- * @param resolve converts descriptor params to a no-arg generator
- * @returns       (params?) => { descriptor, generate }
- */
-export function defineMock(fn, resolve) {
-    return (params) => {
-        const d = { fn, ...params };
-        const result = { descriptor: d };
-        Object.defineProperty(result, 'generate', {
-            value: resolve(d),
-            enumerable: false,
-        });
-        return result;
-    };
-}
+export {};

package/dist/mysql-driver.d.ts

@@ -1,4 +1,8 @@
 import { TableSchema } from './db.js';
+/** Default value constant for created_at columns. */
+export declare const CURRENT_TIMESTAMP = "CURRENT_TIMESTAMP";
+/** Default value constant for updated_at columns (with auto-update). */
+export declare const CURRENT_TIMESTAMP_ON_UPDATE = "CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP";
 export interface BuildCreateTableSqlOptions {
     /** 是否生成外键约束，默认 false（不生成） */
     generateForeignKeys?: boolean;

package/dist/mysql-driver.js

@@ -1,4 +1,8 @@
 // MySQL driver: converts a TableSchema into a CREATE TABLE statement.
+/** Default value constant for created_at columns. */
+export const CURRENT_TIMESTAMP = 'CURRENT_TIMESTAMP';
+/** Default value constant for updated_at columns (with auto-update). */
+export const CURRENT_TIMESTAMP_ON_UPDATE = 'CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP';
 function columnType(field) {
     switch (field.type) {
         case 'string':
@@ -31,9 +35,10 @@ function columnType(field) {
 function renderDefault(field) {
     if (field.default === undefined)
         return '';
-    // CURRENT_TIMESTAMP is a MySQL function keyword, not a string literal.
-    if (field.default === 'CURRENT_TIMESTAMP')
-        return ' DEFAULT CURRENT_TIMESTAMP';
+    // MySQL keyword expressions (CURRENT_TIMESTAMP, CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    // NULL, etc.) — render bare, no quotes.
+    if (/^[A-Z]/.test(field.default))
+        return ` DEFAULT ${field.default}`;
     // Numeric columns take a bare literal, not a quoted one.
     if (field.type === 'integer' || field.type === 'bigint' || field.type === 'decimal' || field.type === 'boolean') {
         return ` DEFAULT ${field.default}`;

package/dist/navigation.d.ts

@@ -0,0 +1,22 @@
+import type { RouteDataSchema } from './route.js';
+import type { ActionSchema } from './action.js';
+import { PageSchema } from './page.js';
+/** Navigation primitives: front-end routing actions that are not provider calls. */
+export interface NavigationAction extends ActionSchema {
+    type: 'navigation';
+    method: 'back' | 'push' | 'popup' | 'home';
+    /** Target page for push navigation. */
+    target?: PageSchema;
+    /** Route params type for push navigation. Auto-derived from target.params if omitted. */
+    params?: RouteDataSchema;
+}
+export declare const navigation: {
+    back(description?: string): NavigationAction;
+    push(options: {
+        target: PageSchema;
+        params?: RouteDataSchema;
+        description?: string;
+    }): NavigationAction;
+    popup(description?: string): NavigationAction;
+    home(description?: string): NavigationAction;
+};

package/dist/navigation.js

@@ -0,0 +1,15 @@
+export const navigation = {
+    back(description) {
+        return { name: 'back', type: 'navigation', method: 'back', description };
+    },
+    push(options) {
+        const { target, params, description } = options;
+        return { name: 'push', type: 'navigation', method: 'push', target, params: params ?? target.params, description };
+    },
+    popup(description) {
+        return { name: 'popup', type: 'navigation', method: 'popup', description };
+    },
+    home(description) {
+        return { name: 'home', type: 'navigation', method: 'home', description };
+    },
+};

package/dist/page-def.d.ts

@@ -0,0 +1,40 @@
+import type { ImportableSchemaBase, CollectionSchemaBase, SchemaBase } from './dsl.js';
+import { DtoField } from './dto.js';
+import type { DtoMessage, DtoArrayField, DtoObjectField } from './dto.js';
+import type { ComponentSchema } from './component.js';
+import type { ActionSchema } from './action.js';
+export type { RouteDataSchema } from './route.js';
+export { defineRouteData } from './route.js';
+/** Page lifecycle events that trigger data loading. */
+export interface EventSchema extends SchemaBase {
+    type: 'onLoad' | 'onShow' | 'onHide' | 'onPullDownRefresh' | 'onReachBottom';
+    /** Actions that fire when this event occurs. */
+    actions?: ActionSchema[];
+}
+export declare const events: {
+    onLoad(actions?: ActionSchema[], description?: string): EventSchema;
+    onShow(actions?: ActionSchema[], description?: string): EventSchema;
+    onHide(actions?: ActionSchema[], description?: string): EventSchema;
+    onPullDownRefresh(actions?: ActionSchema[], description?: string): EventSchema;
+    onReachBottom(actions?: ActionSchema[], description?: string): EventSchema;
+};
+/** Page data: a named collection of fields that defines the page's data shape. */
+export interface PageDataSchema extends CollectionSchemaBase {
+    type: 'pageData';
+    fields: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField>;
+}
+export declare function definePageData(fields: PageDataSchema['fields']): PageDataSchema;
+/** Page skeleton definition. */
+export interface PageDef extends ImportableSchemaBase {
+    data: PageDataSchema;
+    /** Lifecycle events that trigger data loading. */
+    events: EventSchema[];
+    /** Page actions (provider calls, navigation, etc.). */
+    actions: ActionSchema[];
+    /** UI component declarations that make up the page skeleton. */
+    components: ComponentSchema[];
+    /** Whether the driver should generate page-level loading / error / empty state wrappers. */
+    handleStates?: boolean;
+}
+/** Define a page skeleton. */
+export declare function definePageDef(name: string, schema: Omit<PageDef, 'name'>): PageDef;

package/dist/page-def.js

@@ -0,0 +1,38 @@
+import { DtoField } from './dto.js';
+export { defineRouteData } from './route.js';
+export const events = {
+    onLoad(actions, description) {
+        return { name: 'onLoad', type: 'onLoad', actions, description };
+    },
+    onShow(actions, description) {
+        return { name: 'onShow', type: 'onShow', actions, description };
+    },
+    onHide(actions, description) {
+        return { name: 'onHide', type: 'onHide', actions, description };
+    },
+    onPullDownRefresh(actions, description) {
+        return { name: 'onPullDownRefresh', type: 'onPullDownRefresh', actions, description };
+    },
+    onReachBottom(actions, description) {
+        return { name: 'onReachBottom', type: 'onReachBottom', actions, description };
+    },
+};
+export function definePageData(fields) {
+    // Page data has no meaningful identity of its own; the page name already
+    // scopes it, so the schema name defaults to 'data'.
+    const data = { name: 'data', type: 'pageData', fields };
+    // Write back field names (same convention as buildMessage) so defineRef
+    // produces refs with a real field name instead of ''.
+    for (const key of Object.keys(data.fields)) {
+        const df = data.fields[key];
+        if (df instanceof DtoField) {
+            df.name = key;
+            df.schema = data;
+        }
+    }
+    return data;
+}
+/** Define a page skeleton. */
+export function definePageDef(name, schema) {
+    return { name, ...schema };
+}

package/dist/page-flow.d.ts

@@ -1,5 +1,6 @@
 import { SchemaBase } from './dsl.js';
-import { ActionSchema, Page } from './page.js';
+import type { ActionSchema } from './action.js';
+import { Page } from './page.js';
 export interface PageEdge extends SchemaBase {
     /** Trigger action; undefined = default path (success/normal). */
     when?: ActionSchema;
@@ -9,13 +10,14 @@ export interface PageEdge extends SchemaBase {
 export interface PageFlow extends SchemaBase {
     /** Entry page. */
     start: Page;
-    /** All pages, collected from edges (deduplicated by object identity). */
+    /** All pages explicitly declared by the caller. */
     pages: Page[];
     edges: PageEdge[];
 }
 export declare function pageEdge(start: Page, end: Page, when?: ActionSchema, description?: string): PageEdge;
 export declare function definePageFlow(name: string, schema: {
     start: Page;
+    pages: Page[];
     edges: PageEdge[];
     description?: string;
 }): PageFlow;

package/dist/page-flow.js

@@ -1,21 +1,116 @@
+import { getRegisteredPages, clearRegisteredPages } from './page.js';
 export function pageEdge(start, end, when, description) {
     // Auto name for uniformity with SchemaBase; `when` stays the branch marker.
     return { name: `${start.name}->${end.name}`, start, end, when, description };
 }
 export function definePageFlow(name, schema) {
-    const seen = new Set();
-    const pages = [];
-    for (const e of schema.edges) {
-        for (const p of [e.start, e.end]) {
-            if (!seen.has(p)) {
-                seen.add(p);
-                pages.push(p);
-            }
+    const { start, pages, edges: explicitEdges, description } = schema;
+    // Resolve the back action from any page's actions list (PageSchema at runtime)
+    const backAction = findBackAction(pages);
+    // Auto-generate back edges: for every explicit edge A→B (not itself a back),
+    // if B has no explicit back edge and no existing edge B→A, add B→A with back.
+    const hasExplicitBack = new Set();
+    for (const e of explicitEdges) {
+        if (e.when && e.when.name === 'back')
+            hasExplicitBack.add(e.start);
+    }
+    const hasReverse = new Set();
+    for (const e of explicitEdges) {
+        hasReverse.add(`${e.start.name}->${e.end.name}`);
+    }
+    const generatedBackEdges = [];
+    if (backAction) {
+        for (const e of explicitEdges) {
+            if (e.when && e.when.name === 'back')
+                continue;
+            if (hasExplicitBack.has(e.end))
+                continue;
+            if (hasReverse.has(`${e.end.name}->${e.start.name}`))
+                continue;
+            generatedBackEdges.push({
+                name: `${e.end.name}->${e.start.name}`,
+                start: e.end,
+                end: e.start,
+                when: backAction,
+                description: 'auto-generated back edge',
+            });
+            hasExplicitBack.add(e.end);
+        }
+    }
+    const edges = [...explicitEdges, ...generatedBackEdges];
+    // Validate: every registered page must be in the flow's pages
+    const registered = getRegisteredPages();
+    const orphaned = [];
+    for (const rp of registered) {
+        // Compare by object identity — caller passes the same reference
+        if (!pages.includes(rp)) {
+            orphaned.push(rp.name);
+        }
+    }
+    if (orphaned.length > 0) {
+        throw new Error(`[definePageFlow "${name}"] orphaned pages (defined but not in flow): ${orphaned.join(', ')}`);
+    }
+    clearRegisteredPages();
+    // Validate: start must be in pages
+    if (!pages.includes(start)) {
+        throw new Error(`[definePageFlow "${name}"] start page "${start.name}" not in pages`);
+    }
+    // Validate: every page appears in at least one edge
+    const inEdge = new Set();
+    for (const e of edges) {
+        inEdge.add(e.start);
+        inEdge.add(e.end);
+    }
+    const isolated = [];
+    for (const p of pages) {
+        if (!inEdge.has(p))
+            isolated.push(p.name);
+    }
+    if (isolated.length > 0) {
+        throw new Error(`[definePageFlow "${name}"] isolated pages (no edges): ${isolated.join(', ')}`);
+    }
+    // Validate: all pages reachable from start
+    const adj = new Map();
+    for (const p of pages)
+        adj.set(p, []);
+    for (const e of edges) {
+        const neighbors = adj.get(e.start);
+        if (neighbors)
+            neighbors.push(e.end);
+    }
+    const visited = new Set();
+    const stack = [start];
+    while (stack.length > 0) {
+        const cur = stack.pop();
+        if (visited.has(cur))
+            continue;
+        visited.add(cur);
+        for (const next of adj.get(cur) ?? []) {
+            if (!visited.has(next))
+                stack.push(next);
         }
     }
-    if (!seen.has(schema.start)) {
-        seen.add(schema.start);
-        pages.push(schema.start);
+    const unreachable = [];
+    for (const p of pages) {
+        if (!visited.has(p))
+            unreachable.push(p.name);
+    }
+    if (unreachable.length > 0) {
+        throw new Error(`[definePageFlow "${name}"] unreachable pages: ${unreachable.join(', ')}`);
+    }
+    return { name, description, start, pages, edges };
+}
+/** Walk all pages' pageDef.actions (PageSchema runtime shape) to find a NavigationAction with method 'back'. */
+function findBackAction(pages) {
+    for (const p of pages) {
+        const pageDef = p.pageDef;
+        if (!pageDef?.actions)
+            continue;
+        for (const a of pageDef.actions) {
+            const na = a;
+            if (na.type === 'navigation' && na.method === 'back')
+                return na;
+        }
     }
-    return { name, description: schema.description, start: schema.start, pages, edges: schema.edges };
+    return undefined;
 }