instant-cli 0.22.96-experimental.drewh-ts-target.20761590091.1 → 0.22.96-experimental.surgical.20765817844.1

package/dist/util/updateSchemaFile.js

@@ -0,0 +1,610 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as acorn from 'acorn';
+import { tsPlugin } from 'acorn-typescript';
+import { diffSchemas, renderAttrCall, renderAttrProperty, renderEntityProperty, renderLinkProperty, renderLinkValue, } from '@instantdb/platform';
+const parser = acorn.Parser.extend(tsPlugin({ dts: false }));
+const DEFAULT_INDENT = '  ';
+export function updateSchemaFile(existingFileContent, localSchema, serverSchema) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ast = parseFile(existingFileContent);
+        const schemaObj = findSchemaObject(ast);
+        if (!schemaObj) {
+            throw new Error('Could not find i.schema(...) in schema file.');
+        }
+        const { entitiesObj, linksObj } = getSchemaSections(schemaObj);
+        const diff = yield diffSchemas(localSchema, serverSchema, (created) => __awaiter(this, void 0, void 0, function* () { return created; }), {});
+        if (diff.length === 0) {
+            return existingFileContent;
+        }
+        const { entitiesByName } = buildEntitiesIndex(entitiesObj);
+        const { localLinksByForward, serverLinksByForward } = buildLinkMaps(localSchema.links || {}, serverSchema.links || {});
+        const changeBuckets = collectChanges(diff, localLinksByForward, serverLinksByForward);
+        const edits = [];
+        edits.push(...collectEntityEdits(existingFileContent, entitiesObj, entitiesByName, changeBuckets, serverSchema));
+        edits.push(...collectLinkEdits(existingFileContent, linksObj, changeBuckets, localLinksByForward, serverLinksByForward));
+        const updated = applyEdits(existingFileContent, edits);
+        return normalizeEmptyLinksObject(updated);
+    });
+}
+function parseFile(content) {
+    return parser.parse(content, {
+        sourceType: 'module',
+        ecmaVersion: 'latest',
+    });
+}
+function getSchemaSections(schemaObj) {
+    const entitiesProp = findObjectProperty(schemaObj, 'entities');
+    if (!entitiesProp || !isObjectExpression(entitiesProp.value)) {
+        throw new Error('Could not find entities object in schema file.');
+    }
+    const linksProp = findObjectProperty(schemaObj, 'links');
+    if (!linksProp || !isObjectExpression(linksProp.value)) {
+        throw new Error('Could not find links object in schema file.');
+    }
+    return {
+        entitiesObj: entitiesProp.value,
+        linksObj: linksProp.value,
+    };
+}
+function buildEntitiesIndex(entitiesObj) {
+    const entitiesByName = new Map();
+    for (const prop of entitiesObj.properties) {
+        if (!isProperty(prop))
+            continue;
+        const name = getPropName(prop);
+        if (!name)
+            continue;
+        const attrsObj = getEntityAttrsObject(prop.value);
+        if (!attrsObj)
+            continue;
+        const attrsByName = new Map();
+        for (const attrProp of attrsObj.properties) {
+            if (!isProperty(attrProp))
+                continue;
+            const attrName = getPropName(attrProp);
+            if (!attrName)
+                continue;
+            attrsByName.set(attrName, attrProp);
+        }
+        entitiesByName.set(name, { prop, attrsObj, attrsByName });
+    }
+    return { entitiesByName };
+}
+function buildLinkMaps(localLinks, serverLinks) {
+    return {
+        localLinksByForward: buildLinkForwardMap(localLinks),
+        serverLinksByForward: buildLinkForwardMap(serverLinks),
+    };
+}
+function collectEntityEdits(content, entitiesObj, entitiesByName, changeBuckets, serverSchema) {
+    var _a, _b, _c, _d, _e;
+    const edits = [];
+    for (const entityName of changeBuckets.deleteEntities) {
+        const entity = entitiesByName.get(entityName);
+        if (!entity)
+            continue;
+        edits.push(removeProperty(content, entitiesObj, entity.prop));
+    }
+    for (const entityName of changeBuckets.createEntities) {
+        if (entitiesByName.has(entityName))
+            continue;
+        const entityDef = (_a = serverSchema.entities) === null || _a === void 0 ? void 0 : _a[entityName];
+        if (!entityDef)
+            continue;
+        const propText = renderEntityProperty(entityName, entityDef.attrs);
+        const indent = getObjectPropIndent(content, entitiesObj);
+        edits.push(insertProperty(content, entitiesObj, propText, indent));
+    }
+    for (const [entityName, attrs] of changeBuckets.deleteAttrs) {
+        const entity = entitiesByName.get(entityName);
+        if (!entity)
+            continue;
+        for (const attrName of attrs) {
+            const attrProp = entity.attrsByName.get(attrName);
+            if (!attrProp)
+                continue;
+            edits.push(removeProperty(content, entity.attrsObj, attrProp));
+        }
+    }
+    for (const [entityName, attrs] of changeBuckets.addAttrs) {
+        const entity = entitiesByName.get(entityName);
+        if (!entity)
+            continue;
+        const entityDef = (_b = serverSchema.entities) === null || _b === void 0 ? void 0 : _b[entityName];
+        if (!entityDef)
+            continue;
+        const indent = getObjectPropIndent(content, entity.attrsObj);
+        for (const attrName of attrs) {
+            const attrDef = (_c = entityDef.attrs) === null || _c === void 0 ? void 0 : _c[attrName];
+            if (!attrDef)
+                continue;
+            const propText = renderAttrProperty(attrName, attrDef);
+            edits.push(insertPropertyExpandingSingleLine(content, entity.attrsObj, propText, indent));
+        }
+    }
+    for (const [entityName, attrs] of changeBuckets.updateAttrs) {
+        const entity = entitiesByName.get(entityName);
+        if (!entity)
+            continue;
+        const entityDef = (_d = serverSchema.entities) === null || _d === void 0 ? void 0 : _d[entityName];
+        if (!entityDef)
+            continue;
+        for (const attrName of attrs) {
+            const attrProp = entity.attrsByName.get(attrName);
+            const attrDef = (_e = entityDef.attrs) === null || _e === void 0 ? void 0 : _e[attrName];
+            if (!attrProp || !attrDef)
+                continue;
+            edits.push(updateAttrEdit(content, attrProp, attrDef));
+        }
+    }
+    return edits;
+}
+function collectLinkEdits(content, linksObj, changeBuckets, localLinksByForward, serverLinksByForward) {
+    const edits = [];
+    for (const forwardKey of changeBuckets.deleteLinks) {
+        const localLink = localLinksByForward.get(forwardKey);
+        if (!localLink)
+            continue;
+        const linkProp = findObjectProperty(linksObj, localLink.name);
+        if (!linkProp)
+            continue;
+        edits.push(removeProperty(content, linksObj, linkProp));
+    }
+    for (const forwardKey of changeBuckets.addLinks) {
+        const serverLink = serverLinksByForward.get(forwardKey);
+        if (!serverLink)
+            continue;
+        const linkName = serverLink.name;
+        if (findObjectProperty(linksObj, linkName))
+            continue;
+        const propText = renderLinkProperty(linkName, serverLink.link);
+        const indent = getObjectPropIndent(content, linksObj);
+        edits.push(insertProperty(content, linksObj, propText, indent));
+    }
+    for (const forwardKey of changeBuckets.updateLinks) {
+        const serverLink = serverLinksByForward.get(forwardKey);
+        const localLink = localLinksByForward.get(forwardKey);
+        if (!serverLink || !localLink)
+            continue;
+        const linkProp = findObjectProperty(linksObj, localLink.name);
+        if (!linkProp)
+            continue;
+        const nextValue = renderLinkValue(serverLink.link);
+        const propIndent = getLineIndent(content, linkProp.start);
+        edits.push({
+            start: linkProp.value.start,
+            end: linkProp.value.end,
+            text: indentValueAfterFirstLine(nextValue, propIndent),
+        });
+    }
+    return edits;
+}
+function updateAttrEdit(content, attrProp, attrDef) {
+    const { typeParams } = analyzeChain(attrProp.value);
+    const typeParamsText = typeParams
+        ? content.slice(typeParams.start, typeParams.end)
+        : null;
+    const nextValue = renderAttrCall(attrDef, typeParamsText);
+    return {
+        start: attrProp.value.start,
+        end: attrProp.value.end,
+        text: nextValue,
+    };
+}
+function applyEdits(content, edits) {
+    if (edits.length === 0) {
+        return content;
+    }
+    const sorted = [...edits].sort((a, b) => b.start - a.start);
+    let output = content;
+    for (const edit of sorted) {
+        output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+    }
+    return output;
+}
+function collectChanges(steps, localLinksByForward, serverLinksByForward) {
+    var _a;
+    const buckets = {
+        createEntities: new Set(),
+        deleteEntities: new Set(),
+        addAttrs: new Map(),
+        deleteAttrs: new Map(),
+        updateAttrs: new Map(),
+        addLinks: new Set(),
+        deleteLinks: new Set(),
+        updateLinks: new Set(),
+    };
+    for (const step of steps) {
+        const namespace = step.identifier.namespace;
+        const attrName = step.identifier.attrName;
+        const forwardKey = `${namespace}.${attrName}`;
+        switch (step.type) {
+            case 'add-attr': {
+                if (attrName === 'id') {
+                    buckets.createEntities.add(namespace);
+                    break;
+                }
+                if (step['value-type'] === 'ref') {
+                    buckets.addLinks.add(forwardKey);
+                    break;
+                }
+                ensureSet(buckets.addAttrs, namespace).add(attrName);
+                break;
+            }
+            case 'delete-attr': {
+                if (attrName === 'id') {
+                    buckets.deleteEntities.add(namespace);
+                    break;
+                }
+                if (localLinksByForward.has(forwardKey)) {
+                    buckets.deleteLinks.add(forwardKey);
+                    break;
+                }
+                ensureSet(buckets.deleteAttrs, namespace).add(attrName);
+                break;
+            }
+            case 'update-attr': {
+                if (((_a = step.partialAttr) === null || _a === void 0 ? void 0 : _a['value-type']) === 'ref') {
+                    buckets.updateLinks.add(forwardKey);
+                    break;
+                }
+                ensureSet(buckets.updateAttrs, namespace).add(attrName);
+                break;
+            }
+            case 'index':
+            case 'remove-index':
+            case 'unique':
+            case 'remove-unique':
+            case 'required':
+            case 'remove-required':
+            case 'check-data-type':
+            case 'remove-data-type': {
+                if (serverLinksByForward.has(forwardKey)) {
+                    buckets.updateLinks.add(forwardKey);
+                    break;
+                }
+                ensureSet(buckets.updateAttrs, namespace).add(attrName);
+                break;
+            }
+            default: {
+                assertNever(step);
+            }
+        }
+    }
+    pruneNamespaceBuckets(buckets);
+    return buckets;
+}
+function ensureSet(map, key) {
+    if (!map.has(key))
+        map.set(key, new Set());
+    return map.get(key);
+}
+function pruneNamespaceBuckets(buckets) {
+    const namespaces = new Set([
+        ...buckets.createEntities,
+        ...buckets.deleteEntities,
+    ]);
+    for (const namespace of namespaces) {
+        buckets.addAttrs.delete(namespace);
+        buckets.deleteAttrs.delete(namespace);
+        buckets.updateAttrs.delete(namespace);
+        removeNamespaceLinks(buckets.addLinks, namespace);
+        removeNamespaceLinks(buckets.deleteLinks, namespace);
+        removeNamespaceLinks(buckets.updateLinks, namespace);
+    }
+}
+function removeNamespaceLinks(set, namespace) {
+    const prefix = `${namespace}.`;
+    for (const key of Array.from(set)) {
+        if (key.startsWith(prefix)) {
+            set.delete(key);
+        }
+    }
+}
+function assertNever(value) {
+    throw new Error(`Unhandled migration step: ${JSON.stringify(value)}`);
+}
+function analyzeChain(node) {
+    var _a;
+    let curr = node;
+    let typeParams = null;
+    while ((curr === null || curr === void 0 ? void 0 : curr.type) === 'CallExpression') {
+        if (curr.typeParameters) {
+            typeParams = curr.typeParameters;
+        }
+        if (((_a = curr.callee) === null || _a === void 0 ? void 0 : _a.type) === 'MemberExpression') {
+            curr = curr.callee.object;
+        }
+        else {
+            break;
+        }
+    }
+    return { typeParams };
+}
+function findSchemaObject(ast) {
+    let schemaObj = null;
+    const walk = (node) => {
+        var _a, _b, _c, _d;
+        if (!node || schemaObj)
+            return;
+        if (node.type === 'CallExpression' &&
+            ((_a = node.callee) === null || _a === void 0 ? void 0 : _a.type) === 'MemberExpression' &&
+            ((_b = node.callee.object) === null || _b === void 0 ? void 0 : _b.type) === 'Identifier' &&
+            node.callee.object.name === 'i' &&
+            ((_c = node.callee.property) === null || _c === void 0 ? void 0 : _c.name) === 'schema' &&
+            ((_d = node.arguments) === null || _d === void 0 ? void 0 : _d.length) > 0) {
+            const arg = node.arguments[0];
+            if (isObjectExpression(arg)) {
+                schemaObj = arg;
+            }
+            return;
+        }
+        for (const key in node) {
+            if (key === 'loc' || key === 'start' || key === 'end')
+                continue;
+            const value = node[key];
+            if (!value || typeof value !== 'object')
+                continue;
+            if (Array.isArray(value)) {
+                value.forEach(walk);
+            }
+            else {
+                walk(value);
+            }
+        }
+    };
+    walk(ast);
+    return schemaObj;
+}
+function findObjectProperty(obj, name) {
+    for (const prop of obj.properties) {
+        if (!isProperty(prop))
+            continue;
+        const propName = getPropName(prop);
+        if (propName === name)
+            return prop;
+    }
+    return null;
+}
+function getEntityAttrsObject(value) {
+    var _a, _b, _c, _d;
+    if ((value === null || value === void 0 ? void 0 : value.type) !== 'CallExpression' ||
+        ((_a = value.callee) === null || _a === void 0 ? void 0 : _a.type) !== 'MemberExpression' ||
+        ((_b = value.callee.object) === null || _b === void 0 ? void 0 : _b.type) !== 'Identifier' ||
+        value.callee.object.name !== 'i' ||
+        ((_c = value.callee.property) === null || _c === void 0 ? void 0 : _c.name) !== 'entity') {
+        return null;
+    }
+    const attrsObj = (_d = value.arguments) === null || _d === void 0 ? void 0 : _d[0];
+    return isObjectExpression(attrsObj) ? attrsObj : null;
+}
+function buildLinkForwardMap(links) {
+    const map = new Map();
+    for (const [name, link] of Object.entries(links || {})) {
+        map.set(linkForwardKey(link), { name, link });
+    }
+    return map;
+}
+function linkForwardKey(link) {
+    return `${link.forward.on}.${link.forward.label}`;
+}
+function isObjectExpression(node) {
+    return (node === null || node === void 0 ? void 0 : node.type) === 'ObjectExpression';
+}
+function isProperty(node) {
+    return (node === null || node === void 0 ? void 0 : node.type) === 'Property';
+}
+function getPropName(prop) {
+    if (prop.key.type === 'Identifier')
+        return prop.key.name;
+    if (prop.key.type === 'Literal')
+        return String(prop.key.value);
+    return null;
+}
+function indentLines(text, indent) {
+    return text
+        .split('\n')
+        .map((line) => (line.length ? indent + line : line))
+        .join('\n');
+}
+function getObjectPropIndent(source, obj) {
+    const props = obj.properties.filter(isProperty);
+    if (props.length > 0) {
+        return getLineIndent(source, props[0].start);
+    }
+    const closingIndent = getLineIndent(source, obj.end - 1);
+    return closingIndent + DEFAULT_INDENT;
+}
+function getLineIndent(source, pos) {
+    const lineStart = source.lastIndexOf('\n', pos - 1) + 1;
+    const match = source.slice(lineStart, pos).match(/^[\t ]*/);
+    return match ? match[0] : '';
+}
+function insertProperty(source, obj, propText, indent) {
+    const props = obj.properties.filter(isProperty);
+    const closingBrace = obj.end - 1;
+    const propTextWithIndent = indentLines(propText, indent);
+    const propTextSingleLine = propText.trim();
+    const innerStart = obj.start + 1;
+    const innerEnd = closingBrace;
+    const innerContent = source.slice(innerStart, innerEnd);
+    const innerWhitespaceOnly = /^[\s]*$/.test(innerContent);
+    if (props.length === 0) {
+        const objSource = source.slice(obj.start, obj.end);
+        const multiline = objSource.includes('\n') || propText.includes('\n');
+        if (!multiline) {
+            return {
+                start: closingBrace,
+                end: closingBrace,
+                text: ` ${propTextSingleLine} `,
+            };
+        }
+        const closingIndent = getLineIndent(source, closingBrace);
+        if (innerWhitespaceOnly) {
+            return {
+                start: innerStart,
+                end: innerEnd,
+                text: `\n${propTextWithIndent},\n${closingIndent}`,
+            };
+        }
+        return {
+            start: closingBrace,
+            end: closingBrace,
+            text: `\n${propTextWithIndent},\n${closingIndent}`,
+        };
+    }
+    const lastProp = props[props.length - 1];
+    const multiline = source.slice(lastProp.end, closingBrace).includes('\n') ||
+        propText.includes('\n');
+    const needsComma = !hasTrailingComma(source, lastProp.end, obj.end);
+    if (!multiline) {
+        let insertPos = closingBrace;
+        while (insertPos > lastProp.end && /\s/.test(source[insertPos - 1])) {
+            insertPos -= 1;
+        }
+        return {
+            start: insertPos,
+            end: insertPos,
+            text: `${needsComma ? ',' : ''} ${propTextSingleLine}`,
+        };
+    }
+    const lineStart = source.lastIndexOf('\n', closingBrace);
+    return {
+        start: lineStart,
+        end: lineStart,
+        text: `${needsComma ? ',' : ''}\n${propTextWithIndent},`,
+    };
+}
+function removeProperty(source, obj, prop) {
+    let start = prop.start;
+    let end = prop.end;
+    const lineStart = source.lastIndexOf('\n', start - 1) + 1;
+    let shouldTrimLineEnd = false;
+    if (/^[\t ]*$/.test(source.slice(lineStart, start))) {
+        start = lineStart;
+        shouldTrimLineEnd = true;
+    }
+    const after = skipWhitespaceAndComments(source, end, obj.end);
+    if (source[after] === ',') {
+        end = after + 1;
+    }
+    else {
+        const before = skipWhitespaceAndCommentsBackward(source, start, obj.start);
+        if (source[before] === ',') {
+            start = before;
+        }
+    }
+    if (shouldTrimLineEnd) {
+        const lineEnd = source.indexOf('\n', end);
+        if (lineEnd !== -1 && /^[\t ]*$/.test(source.slice(end, lineEnd))) {
+            end = lineEnd + 1;
+        }
+    }
+    return { start, end, text: '' };
+}
+function indentValueAfterFirstLine(value, indent) {
+    const lines = value.split('\n');
+    if (lines.length <= 1)
+        return value;
+    return [
+        lines[0],
+        ...lines.slice(1).map((line) => (line ? indent + line : line)),
+    ].join('\n');
+}
+function insertPropertyExpandingSingleLine(source, obj, propText, indent) {
+    const props = obj.properties.filter(isProperty);
+    if (!props.length) {
+        return insertProperty(source, obj, propText, indent);
+    }
+    const objSource = source.slice(obj.start, obj.end);
+    if (objSource.includes('\n') || propText.includes('\n')) {
+        return insertProperty(source, obj, propText, indent);
+    }
+    const closingBrace = obj.end - 1;
+    const closingIndent = getLineIndent(source, closingBrace);
+    const innerIndent = closingIndent + DEFAULT_INDENT;
+    const propTexts = props.map((prop) => source.slice(prop.start, prop.end).trim());
+    const lines = [...propTexts, propText.trim()].map((prop) => `${innerIndent}${prop},`);
+    const nextObject = `{\n${lines.join('\n')}\n${closingIndent}}`;
+    return { start: obj.start, end: obj.end, text: nextObject };
+}
+function normalizeEmptyLinksObject(content) {
+    let ast;
+    try {
+        ast = parseFile(content);
+    }
+    catch (_a) {
+        return content;
+    }
+    const schemaObj = findSchemaObject(ast);
+    if (!schemaObj)
+        return content;
+    const linksProp = findObjectProperty(schemaObj, 'links');
+    if (!linksProp || !isObjectExpression(linksProp.value))
+        return content;
+    if (linksProp.value.properties.some(isProperty))
+        return content;
+    const inner = content.slice(linksProp.value.start + 1, linksProp.value.end - 1);
+    if (!/^[\s]*$/.test(inner))
+        return content;
+    return (content.slice(0, linksProp.value.start) +
+        '{}' +
+        content.slice(linksProp.value.end));
+}
+function hasTrailingComma(source, afterPos, endPos) {
+    const next = skipWhitespaceAndComments(source, afterPos, endPos);
+    return source[next] === ',';
+}
+function skipWhitespaceAndComments(source, start, end) {
+    let i = start;
+    while (i < end) {
+        const ch = source[i];
+        if (/\s/.test(ch)) {
+            i += 1;
+            continue;
+        }
+        if (ch === '/' && source[i + 1] === '/') {
+            const nextLine = source.indexOf('\n', i + 2);
+            i = nextLine === -1 ? end : nextLine + 1;
+            continue;
+        }
+        if (ch === '/' && source[i + 1] === '*') {
+            const close = source.indexOf('*/', i + 2);
+            i = close === -1 ? end : close + 2;
+            continue;
+        }
+        break;
+    }
+    return i;
+}
+function skipWhitespaceAndCommentsBackward(source, start, end) {
+    let i = start - 1;
+    while (i >= end) {
+        const ch = source[i];
+        if (/\s/.test(ch)) {
+            i -= 1;
+            continue;
+        }
+        if (ch === '/' && source[i - 1] === '/') {
+            const prevLine = source.lastIndexOf('\n', i - 2);
+            i = prevLine === -1 ? end - 1 : prevLine - 1;
+            continue;
+        }
+        if (ch === '/' && source[i - 1] === '*') {
+            const open = source.lastIndexOf('/*', i - 2);
+            i = open === -1 ? end - 1 : open - 1;
+            continue;
+        }
+        break;
+    }
+    return i;
+}
+//# sourceMappingURL=updateSchemaFile.js.map