fimo 0.3.1 → 0.3.2-experimental.1783354419249

package/dist/scripts/scan-wrappable.js

@@ -0,0 +1,231 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { parseSync } from 'oxc-parser';
+// Elements whose subtree counts as already wrapped.
+const WRAPPING_COMPONENTS = new Set([
+    'FimoText',
+    'FimoRichTextBlock',
+    'FimoMediaImage',
+    'FimoMediaVideo',
+    'FimoFileLink',
+    'Text',
+    'RichText',
+]);
+const IMAGE_ELEMENTS = new Set(['img', 'Image']);
+const VIDEO_ELEMENTS = new Set(['video', 'source', 'Video']);
+const WRAPPABLE_ATTRIBUTES = new Set(['placeholder', 'title', 'aria-label']);
+const FILE_LINK_PATTERN = /\.(pdf|zip|docx?|xlsx?|pptx?|csv|mp4|mov|webm)$/i;
+const SKIP_DIRS = new Set(['node_modules', '.next', '.git', 'dist', 'build', '.fimo']);
+const MIN_TEXT_LENGTH = 3;
+const PREVIEW_LENGTH = 60;
+function toPreview(value) {
+    const collapsed = value.replace(/\s+/g, ' ').trim();
+    return collapsed.length > PREVIEW_LENGTH ? `${collapsed.slice(0, PREVIEW_LENGTH)}…` : collapsed;
+}
+function lineOf(code, offset) {
+    return code.slice(0, offset).split('\n').length;
+}
+function jsxElementName(node) {
+    const name = node?.openingElement?.name ?? node?.name;
+    if (!name) {
+        return null;
+    }
+    if (name.type === 'JSXIdentifier') {
+        return name.name;
+    }
+    if (name.type === 'JSXMemberExpression') {
+        return name.property?.name ?? null;
+    }
+    return null;
+}
+function attributeValue(node, attribute) {
+    const attrs = node?.openingElement?.attributes ?? [];
+    for (const attr of attrs) {
+        if (attr.type !== 'JSXAttribute' || attr.name?.name !== attribute) {
+            continue;
+        }
+        const value = attr.value;
+        if (value?.type === 'Literal' && typeof value.value === 'string' && value.value.length > 0) {
+            return { value: value.value, start: attr.start ?? node.start ?? 0 };
+        }
+    }
+    return null;
+}
+const WRAPPED_ID_KIND = {
+    FimoText: 'labels',
+    Text: 'labels',
+    FimoRichTextBlock: 'richText',
+    RichText: 'richText',
+    FimoMediaImage: 'media',
+    FimoMediaVideo: 'media',
+    FimoFileLink: 'files',
+};
+export function scanWrappableFile(filePath, code, relPath) {
+    const items = [];
+    let wrapped = 0;
+    const wrappedIds = { labels: [], media: [], richText: [], files: [] };
+    let ast;
+    try {
+        ast = parseSync(filePath, code).program;
+    }
+    catch {
+        return { items, wrapped, wrappedIds };
+    }
+    function visit(node, insideWrapped) {
+        if (!node || typeof node !== 'object') {
+            return;
+        }
+        let childInsideWrapped = insideWrapped;
+        if (node.type === 'JSXElement') {
+            const name = jsxElementName(node);
+            if (name && WRAPPING_COMPONENTS.has(name)) {
+                wrapped += 1;
+                childInsideWrapped = true;
+                const kind = WRAPPED_ID_KIND[name];
+                const id = attributeValue(node, 'id');
+                if (kind && id) {
+                    wrappedIds[kind].push(id.value);
+                }
+            }
+            if (!insideWrapped && name) {
+                if (IMAGE_ELEMENTS.has(name)) {
+                    const src = attributeValue(node, 'src');
+                    if (src) {
+                        items.push({ kind: 'image', file: relPath, line: lineOf(code, src.start), preview: toPreview(src.value) });
+                    }
+                }
+                else if (VIDEO_ELEMENTS.has(name)) {
+                    const src = attributeValue(node, 'src');
+                    if (src) {
+                        items.push({ kind: 'video', file: relPath, line: lineOf(code, src.start), preview: toPreview(src.value) });
+                    }
+                }
+                else if (name === 'a') {
+                    const href = attributeValue(node, 'href');
+                    if (href && FILE_LINK_PATTERN.test(href.value)) {
+                        items.push({
+                            kind: 'file-link',
+                            file: relPath,
+                            line: lineOf(code, href.start),
+                            preview: toPreview(href.value),
+                        });
+                    }
+                }
+                for (const attribute of WRAPPABLE_ATTRIBUTES) {
+                    const value = attributeValue(node, attribute);
+                    if (value) {
+                        items.push({
+                            kind: 'attribute',
+                            file: relPath,
+                            line: lineOf(code, value.start),
+                            preview: `${attribute}: ${toPreview(value.value)}`,
+                        });
+                    }
+                }
+            }
+        }
+        if (node.type === 'JSXText' && !insideWrapped) {
+            const text = String(node.value ?? '');
+            const meaningful = text.replace(/[^\p{L}\p{N}]/gu, '');
+            if (meaningful.length >= MIN_TEXT_LENGTH) {
+                items.push({ kind: 'text', file: relPath, line: lineOf(code, node.start ?? 0), preview: toPreview(text) });
+            }
+        }
+        // t('key') calls count as wrapped content.
+        if (node.type === 'CallExpression' && node.callee?.type === 'Identifier' && node.callee.name === 't') {
+            wrapped += 1;
+            const firstArg = node.arguments?.[0];
+            if (firstArg?.type === 'Literal' && typeof firstArg.value === 'string') {
+                wrappedIds.labels.push(firstArg.value);
+            }
+        }
+        for (const key of Object.keys(node)) {
+            const child = node[key];
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    visit(item, childInsideWrapped);
+                }
+            }
+            else if (typeof child === 'object' && child !== null) {
+                visit(child, childInsideWrapped);
+            }
+        }
+    }
+    visit(ast, false);
+    return { items, wrapped, wrappedIds };
+}
+function collectSourceFiles(dir, out = []) {
+    if (!existsSync(dir)) {
+        return out;
+    }
+    for (const entry of readdirSync(dir)) {
+        if (SKIP_DIRS.has(entry)) {
+            continue;
+        }
+        const full = join(dir, entry);
+        let stats;
+        try {
+            stats = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (stats.isDirectory()) {
+            collectSourceFiles(full, out);
+        }
+        else if (/\.(tsx|jsx)$/.test(entry)) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+/**
+ * Scan a project's source directories for unwrapped content. `dirs` defaults
+ * to the common Next/React layouts that exist under `rootDir`.
+ */
+export function scanWrappable(rootDir, opts = {}) {
+    const dirs = (opts.dirs ?? ['app', 'src', 'pages', 'components']).filter((dir) => existsSync(join(rootDir, dir)));
+    const files = new Set();
+    for (const dir of dirs) {
+        for (const file of collectSourceFiles(join(rootDir, dir))) {
+            files.add(file);
+        }
+    }
+    const items = [];
+    let wrappedCount = 0;
+    const idSets = {
+        labels: new Set(),
+        media: new Set(),
+        richText: new Set(),
+        files: new Set(),
+    };
+    for (const file of files) {
+        let code;
+        try {
+            code = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const result = scanWrappableFile(file, code, relative(rootDir, file));
+        items.push(...result.items);
+        wrappedCount += result.wrapped;
+        for (const kind of ['labels', 'media', 'richText', 'files']) {
+            for (const id of result.wrappedIds[kind]) {
+                idSets[kind].add(id);
+            }
+        }
+    }
+    items.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+    return {
+        items,
+        wrappedCount,
+        filesScanned: files.size,
+        wrappedIds: {
+            labels: [...idSets.labels].sort(),
+            media: [...idSets.media].sort(),
+            richText: [...idSets.richText].sort(),
+            files: [...idSets.files].sort(),
+        },
+    };
+}

package/dist/scripts/scan-wrappable.test.d.ts

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

package/dist/scripts/scan-wrappable.test.js

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import { scanWrappableFile } from './scan-wrappable.js';
+const scan = (code) => scanWrappableFile('/test/page.tsx', code, 'app/page.tsx');
+describe('scanWrappableFile', () => {
+    it('finds hardcoded JSX text with its line', () => {
+        const { items } = scan(`export default function Page() {
+  return (
+    <div>
+      <h1>Ship your site in hours</h1>
+    </div>
+  );
+}`);
+        expect(items).toEqual([{ kind: 'text', file: 'app/page.tsx', line: 4, preview: 'Ship your site in hours' }]);
+    });
+    it('skips whitespace and short fragments', () => {
+        const { items } = scan(`const x = <div> {'a'} <span>ok</span> </div>;`);
+        expect(items.filter((i) => i.kind === 'text')).toEqual([]);
+    });
+    it('finds images, videos, file links, and attribute strings', () => {
+        const { items } = scan(`const x = (
+  <div>
+    <img src="/images/hero.png" alt="Hero" />
+    <video src="/demo.mp4" />
+    <a href="/whitepaper.pdf">Download</a>
+    <input placeholder="Your work email" />
+  </div>
+);`);
+        expect(items.map((i) => i.kind).sort()).toEqual(['attribute', 'file-link', 'image', 'text', 'video']);
+        expect(items.find((i) => i.kind === 'attribute')?.preview).toBe('placeholder: Your work email');
+    });
+    it('treats content inside Fimo wrappers as wrapped', () => {
+        const { items, wrapped } = scan(`const x = (
+  <div>
+    <FimoText id="home.hero.title">Ship your site in hours</FimoText>
+    <FimoMediaImage id="home.hero.image" src="/images/hero.png" alt="Hero" />
+  </div>
+);`);
+        expect(items).toEqual([]);
+        expect(wrapped).toBe(2);
+    });
+    it('collects wrapped ids grouped by kind', () => {
+        const { wrappedIds } = scan(`const x = (
+  <div>
+    <FimoText id="home.hero.title">Title</FimoText>
+    <FimoRichTextBlock id="home.hero.body">Body</FimoRichTextBlock>
+    <FimoMediaImage id="home.hero.image" src="/a.png" />
+    <FimoFileLink id="home.hero.pdf" href="/a.pdf">PDF</FimoFileLink>
+    <input placeholder={String(t('home.hero.email', 'Email'))} />
+  </div>
+);`);
+        expect(wrappedIds).toEqual({
+            labels: ['home.hero.title', 'home.hero.email'],
+            media: ['home.hero.image'],
+            richText: ['home.hero.body'],
+            files: ['home.hero.pdf'],
+        });
+    });
+    it('counts t() calls as wrapped and skips regular links', () => {
+        const { items, wrapped } = scan(`const x = <input placeholder={String(t('home.email', 'Your email'))} />;
+const y = <a href="/about">About</a>;`);
+        expect(items.filter((i) => i.kind === 'attribute')).toEqual([]);
+        expect(items.filter((i) => i.kind === 'file-link')).toEqual([]);
+        expect(wrapped).toBe(1);
+    });
+});

package/dist/scripts/validate-route-metadata.js

@@ -31,6 +31,17 @@ export function validateRouteMetadata(options = {}) {
     const srcDir = path.resolve(cwd, 'src');
     const routesFilePath = path.resolve(srcDir, 'routes.ts');
     const errors = [];
+    // Everything below the i18n checks cross-validates React Router's
+    // src/routes.ts. Adopted (wrapped) projects on another framework declare it
+    // in fimo-config.json — their routes come from framework scans, so only the
+    // framework-neutral config checks apply.
+    const earlyConfig = readJson(configFilePath);
+    const framework = typeof earlyConfig.framework === 'string' ? earlyConfig.framework : 'react-router';
+    if (framework !== 'react-router') {
+        const i18n = validateI18nConfig(earlyConfig);
+        const configRoutes = loadConfigRoutes(earlyConfig);
+        return { errors: i18n.errors, routesChecked: configRoutes.length };
+    }
     // Parse routes from src/routes.ts (file → path mapping)
     let fileRoutes = [];
     if (!fs.existsSync(routesFilePath)) {

package/dist/scripts/validate-schemas.d.ts

@@ -0,0 +1,13 @@
+export interface SchemaFileError {
+    rule: string;
+    message: string;
+    file: string;
+}
+export interface ValidateSchemasResult {
+    errors: SchemaFileError[];
+    schemasChecked: number;
+}
+export declare function validateSchemas(options?: {
+    cwd?: string;
+}): ValidateSchemasResult;
+export declare function validateSchemaFile(absolutePath: string, file: string): SchemaFileError[];

package/dist/scripts/validate-schemas.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { FieldTypeSchema, RESERVED_CONTENT_FIELD_NAMES } from '@fimo/api-contracts';
+/**
+ * Validate `src/schemas/*.json` locally against the same rules the API's
+ * schema validator enforces (field types, reserved field names, required
+ * uid/name). Catching these in `fimo validate` surfaces the real problem
+ * before a `schemas push` can fail with a less direct server error.
+ */
+const SCHEMAS_REL = 'src/schemas';
+const FIELD_TYPES = new Set(FieldTypeSchema.options);
+const RESERVED_FIELD_NAMES = new Set(RESERVED_CONTENT_FIELD_NAMES);
+export function validateSchemas(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const schemasDir = join(cwd, SCHEMAS_REL);
+    if (!existsSync(schemasDir)) {
+        return { errors: [], schemasChecked: 0 };
+    }
+    const files = readdirSync(schemasDir)
+        .filter((f) => f.endsWith('.json'))
+        .sort();
+    const errors = [];
+    for (const fileName of files) {
+        const file = join(SCHEMAS_REL, fileName);
+        errors.push(...validateSchemaFile(join(schemasDir, fileName), file));
+    }
+    return { errors, schemasChecked: files.length };
+}
+export function validateSchemaFile(absolutePath, file) {
+    let schema;
+    try {
+        schema = JSON.parse(readFileSync(absolutePath, 'utf-8'));
+    }
+    catch (error) {
+        return [
+            {
+                rule: 'schemas/parse',
+                message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+                file,
+            },
+        ];
+    }
+    if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
+        return [{ rule: 'schemas/shape', message: 'Schema must be a JSON object.', file }];
+    }
+    const errors = [];
+    const { uid, name, fields } = schema;
+    const expectedUid = basename(file, '.json');
+    if (typeof uid !== 'string' || uid.length === 0) {
+        errors.push({
+            rule: 'schemas/uid',
+            message: `Missing "uid". Set it to the file name: "${expectedUid}".`,
+            file,
+        });
+    }
+    else if (uid !== expectedUid) {
+        errors.push({
+            rule: 'schemas/uid',
+            message: `"uid" is "${uid}" but the file is ${expectedUid}.json — they must match.`,
+            file,
+        });
+    }
+    if (typeof name !== 'string' || name.length === 0) {
+        errors.push({
+            rule: 'schemas/name',
+            message: 'Missing "name" (the human-readable label).',
+            file,
+        });
+    }
+    if (typeof fields !== 'object' || fields === null || Array.isArray(fields)) {
+        errors.push({
+            rule: 'schemas/fields',
+            message: 'Missing "fields" object.',
+            file,
+        });
+        return errors;
+    }
+    for (const [fieldName, definition] of Object.entries(fields)) {
+        if (RESERVED_FIELD_NAMES.has(fieldName)) {
+            errors.push({
+                rule: 'schemas/reserved-field',
+                message: `Field "${fieldName}" is reserved entry metadata — the platform manages it automatically. ` +
+                    `Remove it from the schema${fieldName === 'slug' ? ' (set slug inside entry data on create instead)' : ''}.`,
+                file,
+            });
+            continue;
+        }
+        if (typeof definition !== 'object' || definition === null || Array.isArray(definition)) {
+            errors.push({
+                rule: 'schemas/field-shape',
+                message: `Field "${fieldName}" must be an object like { "type": "string" }.`,
+                file,
+            });
+            continue;
+        }
+        const { type } = definition;
+        if (typeof type !== 'string' || !FIELD_TYPES.has(type)) {
+            errors.push({
+                rule: 'schemas/field-type',
+                message: `Field "${fieldName}" has unsupported type "${String(type)}". Allowed: ${[...FIELD_TYPES].join(', ')}.`,
+                file,
+            });
+        }
+        if ('i18n' in definition) {
+            errors.push({
+                rule: 'schemas/field-i18n',
+                message: `Field "${fieldName}": field-level locale settings ("i18n") are not supported.`,
+                file,
+            });
+        }
+    }
+    return errors;
+}

package/dist/scripts/validate-schemas.test.d.ts

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

package/dist/scripts/validate-schemas.test.js

@@ -0,0 +1,132 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { validateSchemas } from './validate-schemas';
+describe('validateSchemas', () => {
+    let scratch = null;
+    afterEach(() => {
+        if (scratch) {
+            rmSync(scratch, { recursive: true, force: true });
+            scratch = null;
+        }
+    });
+    function writeProject(schemas) {
+        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
+        mkdirSync(join(scratch, 'src/schemas'), { recursive: true });
+        for (const [fileName, schema] of Object.entries(schemas)) {
+            writeFileSync(join(scratch, 'src/schemas', fileName), typeof schema === 'string' ? schema : JSON.stringify(schema, null, 2));
+        }
+        return scratch;
+    }
+    it('accepts a valid schema', () => {
+        const cwd = writeProject({
+            'BlogPost.json': {
+                uid: 'BlogPost',
+                name: 'Blog Posts',
+                fields: {
+                    title: { type: 'string' },
+                    body: { type: 'richtext' },
+                    coverImage: { type: 'media' },
+                    featured: { type: 'boolean' },
+                },
+            },
+        });
+        expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 1 });
+    });
+    it('returns no errors when the schemas directory does not exist', () => {
+        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
+        expect(validateSchemas({ cwd: scratch })).toEqual({ errors: [], schemasChecked: 0 });
+    });
+    it('rejects reserved field names like slug', () => {
+        const cwd = writeProject({
+            'TeamMember.json': {
+                uid: 'TeamMember',
+                name: 'Team Members',
+                fields: {
+                    name: { type: 'string' },
+                    slug: { type: 'string' },
+                },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reserved-field', file: 'src/schemas/TeamMember.json' });
+        expect(errors[0].message).toContain('"slug" is reserved');
+        expect(errors[0].message).toContain('entry data');
+    });
+    it('rejects every reserved metadata name', () => {
+        const cwd = writeProject({
+            'Bad.json': {
+                uid: 'Bad',
+                name: 'Bad',
+                fields: Object.fromEntries(['id', 'documentId', 'slug', 'locale', 'createdAt', 'updatedAt', '__fimo'].map((name) => [
+                    name,
+                    { type: 'string' },
+                ])),
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(7);
+        expect(errors.every((err) => err.rule === 'schemas/reserved-field')).toBe(true);
+    });
+    it('rejects unsupported field types', () => {
+        const cwd = writeProject({
+            'Product.json': {
+                uid: 'Product',
+                name: 'Products',
+                fields: { price: { type: 'decimal' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-type' });
+        expect(errors[0].message).toContain('"decimal"');
+        expect(errors[0].message).toContain('string, richtext, media');
+    });
+    it('rejects field-level i18n settings', () => {
+        const cwd = writeProject({
+            'Page.json': {
+                uid: 'Page',
+                name: 'Pages',
+                fields: { title: { type: 'string', i18n: true } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-i18n' });
+    });
+    it('rejects a uid that does not match the file name', () => {
+        const cwd = writeProject({
+            'TeamMember.json': {
+                uid: 'Member',
+                name: 'Team Members',
+                fields: { name: { type: 'string' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/uid' });
+    });
+    it('rejects missing uid, name, and fields', () => {
+        const cwd = writeProject({ 'Empty.json': {} });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors.map((err) => err.rule)).toEqual(['schemas/uid', 'schemas/name', 'schemas/fields']);
+    });
+    it('reports invalid JSON', () => {
+        const cwd = writeProject({ 'Broken.json': '{ not json' });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/parse' });
+    });
+    it('validates multiple files and counts them', () => {
+        const cwd = writeProject({
+            'Good.json': { uid: 'Good', name: 'Good', fields: { title: { type: 'string' } } },
+            'Bad.json': { uid: 'Bad', name: 'Bad', fields: { slug: { type: 'string' } } },
+        });
+        const result = validateSchemas({ cwd });
+        expect(result.schemasChecked).toBe(2);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0].file).toBe('src/schemas/Bad.json');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.3.1",
+  "version": "0.3.2-experimental.1783354419249",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"
@@ -15,10 +15,23 @@
   ],
   "type": "module",
   "exports": {
+    "./package.json": "./package.json",
     "./ui": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
     },
+    "./react": {
+      "types": "./dist/runtime/react/index.d.ts",
+      "import": "./dist/runtime/react/index.js"
+    },
+    "./next": {
+      "types": "./dist/runtime/next/index.d.ts",
+      "import": "./dist/runtime/next/index.js"
+    },
+    "./next/server": {
+      "types": "./dist/runtime/next/server.d.ts",
+      "import": "./dist/runtime/next/server.js"
+    },
     "./react-router": {
       "types": "./dist/runtime/react-router/index.d.ts",
       "import": "./dist/runtime/react-router/index.js"
@@ -96,11 +109,26 @@
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.80.6",
+    "next": ">=14.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "react-router": "^7.0.0",
     "vite": "^7.0.0 || ^8.0.0"
   },
+  "peerDependenciesMeta": {
+    "@tanstack/react-query": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "react-router": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=20.12.0"
   }

package/release.json

@@ -1,5 +1,5 @@
 {
   "source": "npm",
-  "apiUrl": "https://api.fimo.ai",
-  "webUrl": "https://fimo.ai"
+  "apiUrl": "https://api.staging.fimo.team",
+  "webUrl": "https://staging.fimo.team"
 }