includio-cms 0.1.3 → 0.5.0

package/dist/core/server/entries/operations/update.js

@@ -1,7 +1,9 @@
 import { getCMS } from '../../../cms.js';
 import { generateZodSchemaFromFields } from '../../../fields/fieldSchemaToTs.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 import z from 'zod';
-import { getDbEntryOrThrow, getDbEntryVersionOrThrow } from './get.js';
+import { getDbEntryOrThrow, getDbEntryVersionOrThrow, getDbEntryVersions } from './get.js';
+import { createEntryVersion } from './create.js';
 export const updateEntrySchema = z.object({
     availableLocales: z.array(z.string()).optional(),
     archivedAt: z.date().nullable().optional(),
@@ -57,7 +59,7 @@ export const updateEntryVersion = async (id, data) => {
         const entry = await getDbEntryOrThrow({ id: version.entryId });
         const config = getCMS().getBySlug(entry.slug);
         const languages = getCMS().languages;
-        const schema = generateZodSchemaFromFields(config.fields, languages);
+        const schema = generateZodSchemaFromFields(getFieldsFromConfig(config), languages);
         const parsedData = schema.safeParse(filteredData.data);
         if (!parsedData.success) {
             throw Error('Invalid data: ' + parsedData.error.flatten());
@@ -102,6 +104,32 @@ export const pruneOldDraftVersions = async (entryId) => {
         await Promise.all(toDelete.map((v) => getCMS().databaseAdapter.deleteEntryVersion({ id: v.id })));
     }
 };
+export const upsertDraftVersion = async (entryId, data, options) => {
+    const entry = await getDbEntryOrThrow({ id: entryId });
+    const versions = await getDbEntryVersions({ entryIds: [entryId] });
+    // Sort desc by versionNumber, find latest non-published draft
+    const sorted = versions.sort((a, b) => b.versionNumber - a.versionNumber);
+    const latestDraft = sorted.find((v) => v.id !== entry.publishedVersionId);
+    if (latestDraft) {
+        // Compare data — if identical, skip
+        const existingData = JSON.stringify(latestDraft.data);
+        const newData = JSON.stringify(data);
+        if (existingData === newData) {
+            return latestDraft;
+        }
+        // Different data — update in place
+        const updated = await getCMS().databaseAdapter.updateEntryVersion({
+            id: latestDraft.id,
+            data: {
+                data: data,
+                createdAt: new Date()
+            }
+        });
+        return updated;
+    }
+    // No draft exists — create new version
+    return createEntryVersion({ entryId, data }, options);
+};
 export const unpublishEntry = async (entryId) => {
     await updateEntry(entryId, {
         publishedVersionId: null,

package/dist/core/server/fields/queryStructuredContent.d.ts

@@ -0,0 +1,15 @@
+import type { SCNode, StructuredContentDoc, SCInlineBlockAttrs } from '../../../types/structured-content.js';
+export interface MediaRef {
+    type: 'image' | 'video';
+    src: string;
+    alt?: string;
+    mediaId?: string;
+}
+/** Extract block-level nodes, optionally filtered by type. */
+export declare function extractBlocks(doc: StructuredContentDoc, type?: string): SCNode[];
+/** Extract inline block nodes, optionally filtered by blockType. */
+export declare function extractInlineBlocks(doc: StructuredContentDoc, blockType?: string): SCInlineBlockAttrs[];
+/** Extract all plain text from doc (useful for excerpts, search indexing). */
+export declare function extractText(doc: StructuredContentDoc): string;
+/** Extract media references from figure/video/image nodes. */
+export declare function extractMediaRefs(doc: StructuredContentDoc): MediaRef[];

package/dist/core/server/fields/queryStructuredContent.js

@@ -0,0 +1,65 @@
+import { walkNodes } from '../../../admin/components/tiptap/structured-content-utils.js';
+/** Extract block-level nodes, optionally filtered by type. */
+export function extractBlocks(doc, type) {
+    const result = [];
+    walkNodes(doc.content, (node) => {
+        if (type ? node.type === type : !['doc', 'text'].includes(node.type)) {
+            result.push(node);
+        }
+    });
+    return result;
+}
+/** Extract inline block nodes, optionally filtered by blockType. */
+export function extractInlineBlocks(doc, blockType) {
+    const result = [];
+    walkNodes(doc.content, (node) => {
+        if (node.type !== 'inlineBlock' || !node.attrs)
+            return;
+        const attrs = node.attrs;
+        if (blockType ? attrs.blockType === blockType : true) {
+            result.push(attrs);
+        }
+    });
+    return result;
+}
+/** Extract all plain text from doc (useful for excerpts, search indexing). */
+export function extractText(doc) {
+    const parts = [];
+    walkNodes(doc.content, (node) => {
+        if (node.type === 'text' && node.text) {
+            parts.push(node.text);
+        }
+        else if (node.type === 'hardBreak') {
+            parts.push('\n');
+        }
+    });
+    return parts.join('');
+}
+/** Extract media references from figure/video/image nodes. */
+export function extractMediaRefs(doc) {
+    const refs = [];
+    walkNodes(doc.content, (node) => {
+        if (node.type === 'figure' || node.type === 'image') {
+            const attrs = node.attrs;
+            if (attrs?.src) {
+                refs.push({
+                    type: 'image',
+                    src: attrs.src,
+                    alt: attrs.alt ?? undefined,
+                    mediaId: attrs['data-media-id'] ?? undefined
+                });
+            }
+        }
+        else if (node.type === 'video') {
+            const attrs = node.attrs;
+            if (attrs?.src) {
+                refs.push({
+                    type: 'video',
+                    src: attrs.src,
+                    mediaId: attrs['data-media-id'] ?? undefined
+                });
+            }
+        }
+    });
+    return refs;
+}

package/dist/core/server/fields/resolveImageFields.js

@@ -3,6 +3,7 @@ const PUBLIC_URL = env.PUBLIC_URL ?? '';
 import { getCMS } from '../../cms.js';
 import z from 'zod';
 import { getImageStyles } from './utils/imageStyles.js';
+import { extractMediaIds as extractMediaIdsFromDoc, walkMediaNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
 export async function resolveMediaFields(data, fields) {
     const mediaIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -39,7 +40,7 @@ export async function resolveMediaFields(data, fields) {
                 case 'object':
                     collectIds(val.data, field.fields);
                     break;
-                case 'array':
+                case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             // Find the object definition for this item based on its slug
@@ -50,6 +51,17 @@ export async function resolveMediaFields(data, fields) {
                         });
                     }
                     break;
+                case 'content': {
+                    // Content field is localized: { lang: StructuredContentDoc }
+                    if (typeof val === 'object' && val !== null) {
+                        for (const doc of Object.values(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                mediaIds.push(...extractMediaIdsFromDoc(doc));
+                            }
+                        }
+                    }
+                    break;
+                }
             }
         }
     };
@@ -178,7 +190,7 @@ export async function resolveMediaFields(data, fields) {
                         data: await resolveValues(val.data, field.fields)
                     };
                     break;
-                case 'array':
+                case 'blocks':
                     result[field.slug] = await Promise.all(
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     val.map(async (item) => {
@@ -194,6 +206,43 @@ export async function resolveMediaFields(data, fields) {
                         return item;
                     }));
                     break;
+                case 'content': {
+                    // Content field is localized: { lang: StructuredContentDoc }
+                    if (typeof val === 'object' && val !== null) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const resolved = {};
+                        for (const [lang, doc] of Object.entries(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                const cloned = cloneDoc(doc);
+                                walkMediaNodes(cloned, (node) => {
+                                    const mediaId = node.attrs?.['data-media-id'];
+                                    if (!mediaId)
+                                        return;
+                                    const mediaFile = mediaMap[mediaId];
+                                    if (!mediaFile)
+                                        return;
+                                    node.attrs.src = mediaFile.url;
+                                    if (mediaFile.width)
+                                        node.attrs.width = mediaFile.width;
+                                    if (mediaFile.height)
+                                        node.attrs.height = mediaFile.height;
+                                    if (mediaFile.alt && !node.attrs.alt)
+                                        node.attrs.alt = mediaFile.alt;
+                                    node.attrs._media = {
+                                        data: mediaFile,
+                                        ...(mediaFile.type === 'image' ? { blurDataUrl: mediaFile.blurDataUrl } : {})
+                                    };
+                                });
+                                resolved[lang] = cloned;
+                            }
+                            else {
+                                resolved[lang] = doc;
+                            }
+                        }
+                        result[field.slug] = resolved;
+                    }
+                    break;
+                }
                 default:
                     result[field.slug] = val;
             }

package/dist/core/server/fields/resolveRelationFields.js

@@ -26,7 +26,7 @@ export async function resolveRelationFields(data, fields, language) {
                 case 'object':
                     collectIds(val.data, field.fields);
                     break;
-                case 'array':
+                case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             // Find the object definition for this item based on its slug
@@ -78,7 +78,7 @@ export async function resolveRelationFields(data, fields, language) {
                         data: resolveValues(val.data, field.fields)
                     };
                     break;
-                case 'array':
+                case 'blocks':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     result[field.slug] = val.map((item) => {
                         // Find the object definition for this item based on its slug

package/dist/core/server/fields/resolveRichtextLinks.js

@@ -1,4 +1,6 @@
 import { getCMS } from '../../cms.js';
+import { extractEntryIds as extractEntryIdsFromDoc, extractMediaIds as extractMediaIdsFromDoc, cloneDoc, walkLinkMarks, walkInlineBlockNodes } from '../../../admin/components/tiptap/structured-content-utils.js';
+import { getEntrySlugPath, getSlugFromEntryData } from './slugResolver.js';
 const ENTRY_ID_RE = /data-entry-id="([0-9a-f-]{36})"/g;
 function extractEntryIds(html) {
     const ids = [];
@@ -7,15 +9,47 @@ function extractEntryIds(html) {
     }
     return ids;
 }
-function resolveHtml(html, entriesMap) {
+function resolveHtml(html, slugMap) {
     return html.replace(/<a\s([^>]*data-entry-id="([0-9a-f-]{36})"[^>]*)>/g, (match, _attrs, id) => {
-        const entryData = entriesMap[id]?.data;
-        const slug = entryData?.seo?.slug;
+        const slug = slugMap[id];
         if (!slug)
             return match;
         return match.replace(/href="[^"]*"/, `href="${slug}"`);
     });
 }
+/** Extract entry IDs from inlineBlock blockData relation fields. */
+function extractEntryIdsFromInlineBlocks(doc) {
+    const ids = [];
+    walkInlineBlockNodes(doc, (node) => {
+        const data = node.attrs?.blockData;
+        if (!data || typeof data !== 'object')
+            return;
+        for (const val of Object.values(data)) {
+            if (typeof val === 'string' && val.length === 36)
+                ids.push(val);
+            if (Array.isArray(val)) {
+                for (const item of val) {
+                    if (typeof item === 'string' && item.length === 36)
+                        ids.push(item);
+                }
+            }
+        }
+    });
+    return ids;
+}
+function resolveContentDoc(doc, slugMap) {
+    const cloned = cloneDoc(doc);
+    walkLinkMarks(cloned, (mark) => {
+        const entryId = mark.attrs?.['data-entry-id'];
+        if (!entryId)
+            return;
+        const slug = slugMap[entryId];
+        if (slug && mark.attrs) {
+            mark.attrs.href = slug;
+        }
+    });
+    return cloned;
+}
 export async function resolveRichtextLinks(data, fields, language) {
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -39,10 +73,22 @@ export async function resolveRichtextLinks(data, fields, language) {
                     }
                     break;
                 }
+                case 'content': {
+                    // Content field is localized: { lang: StructuredContentDoc, ... }
+                    if (typeof val === 'object' && val !== null) {
+                        for (const doc of Object.values(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                entriesIds.push(...extractEntryIdsFromDoc(doc));
+                                entriesIds.push(...extractEntryIdsFromInlineBlocks(doc));
+                            }
+                        }
+                    }
+                    break;
+                }
                 case 'object':
                     collectIds(val.data, field.fields);
                     break;
-                case 'array':
+                case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             const objectDef = field.of.find((objDef) => objDef.slug === item.slug);
@@ -71,15 +117,20 @@ export async function resolveRichtextLinks(data, fields, language) {
     const versions = await db.getEntryVersions({
         ids: publishedVersionIds
     });
-    // Build map: entryId → { data: { seo: { slug } } } using raw version data
-    const entriesMap = {};
+    // Build map: entryId → collectionSlug for config lookup
+    const entryConfigSlugMap = {};
+    for (const entry of entries) {
+        entryConfigSlugMap[entry.id] = entry.slug;
+    }
+    // Build map: entryId → resolved slug string
+    const slugMap = {};
     for (const version of versions) {
         const rawData = version.data;
-        const seoRaw = rawData?.seo;
-        const slugField = seoRaw?.slug;
-        const slug = slugField?.[language];
+        const configSlug = entryConfigSlugMap[version.entryId];
+        const slugPath = configSlug ? getEntrySlugPath(configSlug) : 'seo.slug';
+        const slug = getSlugFromEntryData(rawData, slugPath, language);
         if (slug) {
-            entriesMap[version.entryId] = { data: { seo: { slug } } };
+            slugMap[version.entryId] = slug;
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -99,12 +150,28 @@ export async function resolveRichtextLinks(data, fields, language) {
                         const resolved = {};
                         for (const [lang, html] of Object.entries(val)) {
                             resolved[lang] =
-                                typeof html === 'string' ? resolveHtml(html, entriesMap) : html;
+                                typeof html === 'string' ? resolveHtml(html, slugMap) : html;
                         }
                         result[field.slug] = resolved;
                     }
                     else if (typeof val === 'string') {
-                        result[field.slug] = resolveHtml(val, entriesMap);
+                        result[field.slug] = resolveHtml(val, slugMap);
+                    }
+                    break;
+                }
+                case 'content': {
+                    if (typeof val === 'object' && val !== null) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const resolved = {};
+                        for (const [lang, doc] of Object.entries(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                resolved[lang] = resolveContentDoc(doc, slugMap);
+                            }
+                            else {
+                                resolved[lang] = doc;
+                            }
+                        }
+                        result[field.slug] = resolved;
                     }
                     break;
                 }
@@ -114,7 +181,7 @@ export async function resolveRichtextLinks(data, fields, language) {
                         data: resolveValues(val.data, field.fields)
                     };
                     break;
-                case 'array':
+                case 'blocks':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     result[field.slug] = val.map((item) => {
                         const objectDef = field.of.find((objDef) => objDef.slug === item.slug);

package/dist/core/server/fields/resolveUrlFields.js

@@ -1,5 +1,6 @@
 import { urlFieldDataSchema, urlFieldDataWithRelationSchema } from '../../../schemas/field/url.js';
 import { getEntries } from '../entries/operations/get.js';
+import { getEntrySlugPath, getSlugFromEntryData } from './slugResolver.js';
 export async function resolveUrlFields(data, fields, language) {
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -26,7 +27,7 @@ export async function resolveUrlFields(data, fields, language) {
                 case 'object':
                     collectIds(val.data, field.fields);
                     break;
-                case 'array':
+                case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             // Find the object definition for this item based on its slug
@@ -37,14 +38,29 @@ export async function resolveUrlFields(data, fields, language) {
                         });
                     }
                     break;
+                case 'array':
+                    if (field.of === 'url' && Array.isArray(val)) {
+                        for (const item of val) {
+                            const parsedVal = urlFieldDataWithRelationSchema.safeParse(item);
+                            if (parsedVal.success) {
+                                entriesIds.push(parsedVal.data.id);
+                            }
+                        }
+                    }
+                    break;
             }
         }
     };
     collectIds(data, fields);
-    let entriesMap = {};
+    const slugMap = {};
     if (entriesIds.length > 0) {
         const entries = await getEntries({ ids: entriesIds, language });
-        entriesMap = Object.fromEntries(entries.map((m) => [m.id, m]));
+        for (const entry of entries) {
+            const slugPath = getEntrySlugPath(entry.slug);
+            const slug = getSlugFromEntryData(entry.data, slugPath);
+            if (slug)
+                slugMap[entry.id] = slug;
+        }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const resolveValues = (value, fields) => {
@@ -83,8 +99,7 @@ export async function resolveUrlFields(data, fields, language) {
                         extras.newTab = parsed.newTab;
                     }
                     if (parsedValWithRelation.success) {
-                        const entryData = entriesMap[parsedValWithRelation.data.id]?.data;
-                        const slug = entryData?.seo?.slug;
+                        const slug = slugMap[parsedValWithRelation.data.id];
                         if (slug) {
                             result[field.slug] = { url: slug, ...extras };
                             break;
@@ -102,7 +117,7 @@ export async function resolveUrlFields(data, fields, language) {
                         data: resolveValues(val.data, field.fields)
                     };
                     break;
-                case 'array':
+                case 'blocks':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     result[field.slug] = val.map((item) => {
                         // Find the object definition for this item based on its slug
@@ -117,6 +132,42 @@ export async function resolveUrlFields(data, fields, language) {
                         return item;
                     });
                     break;
+                case 'array':
+                    if (field.of === 'url' && Array.isArray(val)) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        result[field.slug] = val.map((item) => {
+                            const parsedValWithRelation = urlFieldDataWithRelationSchema.safeParse(item);
+                            const parsedVal = urlFieldDataSchema.safeParse(item);
+                            const parsed = parsedValWithRelation.success
+                                ? parsedValWithRelation.data
+                                : parsedVal.success
+                                    ? parsedVal.data
+                                    : null;
+                            if (!parsed)
+                                return item;
+                            const extras = {};
+                            if (parsed.text) {
+                                extras.text = language ? parsed.text[language] : parsed.text;
+                            }
+                            if (parsed.newTab !== undefined) {
+                                extras.newTab = parsed.newTab;
+                            }
+                            if (parsedValWithRelation.success) {
+                                const slug = slugMap[parsedValWithRelation.data.id];
+                                if (slug) {
+                                    return { url: slug, ...extras };
+                                }
+                            }
+                            const resolvedUrl = language
+                                ? parsed.url[language]
+                                : parsed.url;
+                            return { url: resolvedUrl, ...extras };
+                        });
+                    }
+                    else {
+                        result[field.slug] = val;
+                    }
+                    break;
                 default:
                     result[field.slug] = val;
             }

package/dist/core/server/fields/slugResolver.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get the dot-path to the slug field for a given collection/single slug.
+ * Falls back to 'seo.slug' if no slugField is configured.
+ */
+export declare function getEntrySlugPath(configSlug: string): string;
+/**
+ * Traverse a dot-path in entry data and return the slug value.
+ * Handles both plain strings and localized objects { lang: string }.
+ */
+export declare function getSlugFromEntryData(data: Record<string, unknown>, slugPath: string, language?: string): string | undefined;

package/dist/core/server/fields/slugResolver.js

@@ -0,0 +1,34 @@
+import { getCMS } from '../../cms.js';
+const DEFAULT_SLUG_PATH = 'seo.slug';
+/**
+ * Get the dot-path to the slug field for a given collection/single slug.
+ * Falls back to 'seo.slug' if no slugField is configured.
+ */
+export function getEntrySlugPath(configSlug) {
+    try {
+        const config = getCMS().getBySlug(configSlug);
+        return config.slugField || DEFAULT_SLUG_PATH;
+    }
+    catch {
+        return DEFAULT_SLUG_PATH;
+    }
+}
+/**
+ * Traverse a dot-path in entry data and return the slug value.
+ * Handles both plain strings and localized objects { lang: string }.
+ */
+export function getSlugFromEntryData(data, slugPath, language) {
+    const parts = slugPath.split('.');
+    let current = data;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    if (typeof current === 'string')
+        return current;
+    if (language && current != null && typeof current === 'object') {
+        return current[language];
+    }
+    return undefined;
+}

package/dist/core/server/generator/fields.js

@@ -6,6 +6,8 @@ function getFieldTypeAsString(field) {
         case 'date':
         case 'datetime':
             return 'string';
+        case 'content':
+            return 'StructuredContentDoc';
         case 'radio':
             return field.options.map((opt) => `'${opt.value.trim()}'`).join(' | ');
         case 'image': {
@@ -39,11 +41,11 @@ function getFieldTypeAsString(field) {
 				slug: '${field.slug}';
 				data: {${field.fields.map((f) => `  ${f.slug}${f.required ? '' : '?'}: ${getFieldTypeAsString(f)}`).join(';\n')}};
 			}`;
-        case 'array':
+        case 'blocks':
             return `
 			(
 			${field.of
-                .map((f) => ` 
+                .map((f) => `
 				{
 					slug: '${f.slug}';
 					data: {${f.fields.map((f) => `  ${f.slug}${f.required ? '' : '?'}: ${getFieldTypeAsString(f)}`).join(';\n')}};
@@ -51,13 +53,22 @@ function getFieldTypeAsString(field) {
 			`)
                 .join(' | ')}
 			)[]`;
+        case 'array':
+            switch (field.of) {
+                case 'text':
+                    return field.localized ? 'Record<string, string>[]' : 'string[]';
+                case 'number':
+                    return 'number[]';
+                case 'url':
+                    return 'UrlFieldData[]';
+            }
         case 'slug':
             return 'string';
         case 'seo':
             return `{
-				slug?: string;
+				slug: string;
 				canonicalUrl?: string;
-				title?: string;
+				title: string;
 				description?: string;
 				ogImage?: string;
 				keywords?: string;

package/dist/core/server/generator/generator.js

@@ -4,6 +4,7 @@ import { generateTsTypeFromFields } from './fields.js';
 import { generateTsTypeFromFormFields } from './formFields.js';
 import { generateZodSchemaStringFromFormFieldsAsString } from './formFieldSchemaToString.js';
 import { toPascalCase } from './utils.js';
+import { getFieldsFromConfig } from '../../fields/layoutUtils.js';
 function createCmsRuntimeDir() {
     const cmsDir = join(process.cwd(), 'src/lib/cms/runtime');
     mkdirSync(cmsDir, { recursive: true });
@@ -19,7 +20,7 @@ function generateTypesStringForRecords(type, records) {
 			export interface ${toPascalCase(single.slug)} {
 				id: string;
 				slug: string;
-				data: ${generateTsTypeFromFields(single.fields)}
+				data: ${generateTsTypeFromFields(getFieldsFromConfig(single))}
 				publishedAt: Date | null;
 			};
 		`;
@@ -68,7 +69,7 @@ function generateTypes(config) {
     const cmsDir = join(process.cwd(), 'src/lib/cms/runtime');
     const filePath = join(cmsDir, 'types.ts');
     let code = `// This file is auto-generated. Do not edit directly.\n\n`;
-    code += `import type { MediaFile, ImageFieldData, VideoFieldData } from 'includio-cms/types';\n\n`;
+    code += `import type { MediaFile, ImageFieldData, VideoFieldData, StructuredContentDoc } from 'includio-cms/types';\n\n`;
     if (config.singles && config.singles.length > 0) {
         code += generateTypesStringForRecords('single', Object.values(config.singles));
     }