@postxl/generator 0.0.1

package/dist/src/prisma/attributes.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldAttributes = exports.getModelAttributes = exports.parseArgumentToStringOrStringArray = exports.parseAttributesFromDocumentation = void 0;
+const remeda_1 = require("remeda");
+const string_1 = require("../lib/utils/string");
+/**
+ * Parses attributes from a given string using provided prefix.
+ */
+function parseAttributesFromDocumentation({ documentation }) {
+    const prefix = '@@';
+    if (!documentation)
+        return {};
+    return documentation
+        .split('\n')
+        .filter((d) => d.startsWith(prefix))
+        .map((d) => d.replace(prefix, ''))
+        .reduce((acc, line) => {
+        const pattern = /(\w+)\((.*?)\)$/;
+        if (!pattern.test(line))
+            return acc;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const [attribute, arg] = line.match(pattern).slice(1);
+        acc[(0, string_1.toCamelCase)(attribute)] = parseArgumentToStringOrStringArray(arg);
+        return acc;
+    }, {});
+}
+exports.parseAttributesFromDocumentation = parseAttributesFromDocumentation;
+function parseArgumentToStringOrStringArray(str) {
+    if (str === '')
+        return '';
+    try {
+        return JSON.parse(str);
+    }
+    catch (_a) {
+        try {
+            return JSON.parse(`[${str}]`);
+        }
+        catch (_b) {
+            console.log(str);
+            return JSON.parse(`"${str}"`);
+        }
+    }
+}
+exports.parseArgumentToStringOrStringArray = parseArgumentToStringOrStringArray;
+/**
+ * Returns attribute information for a given model.
+ */
+function getModelAttributes(model) {
+    const attributes = parseAttributesFromDocumentation(model);
+    return {
+        ignore: Object.hasOwn(attributes, 'ignore'),
+        skipUpdate: Object.hasOwn(attributes, 'skipUpdate') || Object.hasOwn(attributes, 'customUpdate'),
+        skipCreate: Object.hasOwn(attributes, 'skipCreate') || Object.hasOwn(attributes, 'customCreate'),
+        skipDelete: Object.hasOwn(attributes, 'skipDelete') || Object.hasOwn(attributes, 'customDelete'),
+        description: attributes.description && (0, remeda_1.isString)(attributes.description) ? attributes.description : undefined,
+    };
+}
+exports.getModelAttributes = getModelAttributes;
+/**
+ * Returns all attributes assigned to a field
+ */
+function getFieldAttributes(field) {
+    const attributes = parseAttributesFromDocumentation(field);
+    if (attributes.examples === undefined && attributes.example !== undefined) {
+        attributes.examples = attributes.example;
+    }
+    return {
+        // Prisma also has an "@ignore" attribute - see https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#ignore
+        // we handle this the same way as our custom "ignore" attribute
+        ignore: field.isIgnored || Object.hasOwn(attributes, 'ignore'),
+        description: attributes.description && (0, remeda_1.isString)(attributes.description) ? attributes.description : undefined,
+        isDefaultField: Object.hasOwn(attributes, 'isDefaultField'),
+        examples: !attributes.examples
+            ? undefined
+            : Array.isArray(attributes.examples)
+                ? attributes.examples
+                : [attributes.examples],
+    };
+}
+exports.getFieldAttributes = getFieldAttributes;

package/dist/src/prisma/client-path.d.ts

@@ -0,0 +1,7 @@
+import { GeneratorConfig } from '@prisma/generator-helper';
+/**
+ * Returns the the Node import path for the Prisma Client.
+ *
+ * NOTE: This should normally be @prisma/client, but can be different if output is specified in schema.prisma.
+ */
+export declare function getClientImportPath(generators: GeneratorConfig[]): string;

package/dist/src/prisma/client-path.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClientImportPath = void 0;
+/**
+ * Returns the the Node import path for the Prisma Client.
+ *
+ * NOTE: This should normally be @prisma/client, but can be different if output is specified in schema.prisma.
+ */
+function getClientImportPath(generators) {
+    var _a;
+    const clientGenerator = generators.find((g) => g.provider.value === 'prisma-client-js');
+    if (!clientGenerator) {
+        return '@prisma/client';
+    }
+    const output = (_a = clientGenerator.output) === null || _a === void 0 ? void 0 : _a.value;
+    if (!output) {
+        return '@prisma/client';
+    }
+    //if output contains @..., return everything starting from @ and replace \\ with /
+    if (output.includes('@')) {
+        return output.substring(output.lastIndexOf('@')).replace(/\\/g, '/');
+    }
+    //if output contains node_modules, return everything after node_modules and replace \\ with /
+    if (output.includes('node_modules')) {
+        return output.substring(output.indexOf('node_modules') + 'node_modules'.length).replace(/\\/g, '/');
+    }
+    return '@prisma/client';
+}
+exports.getClientImportPath = getClientImportPath;

package/dist/src/prisma/parse.d.ts

@@ -0,0 +1,12 @@
+import { DMMF } from '@prisma/generator-helper';
+import * as Schema from '../lib/schema/schema';
+/**
+ * Converts a Prisma schema (DMMF) document to a Schema that's passed around generators.
+ */
+export declare function parsePrismaSchema({ datamodel: { enums: enumsRaw, models: modelsRaw }, config, }: {
+    datamodel: DMMF.Datamodel;
+    config: Schema.SchemaConfig;
+}): {
+    models: Schema.Model[];
+    enums: Schema.Enum[];
+};

package/dist/src/prisma/parse.js

@@ -0,0 +1,276 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrismaSchema = void 0;
+const Types = __importStar(require("../lib/schema/types"));
+const error_1 = require("../lib/utils/error");
+const string_1 = require("../lib/utils/string");
+const attributes_1 = require("./attributes");
+/**
+ * Converts a Prisma schema (DMMF) document to a Schema that's passed around generators.
+ */
+function parsePrismaSchema({ datamodel: { enums: enumsRaw, models: modelsRaw }, config, }) {
+    // NOTE: We preprocess models and enums so that we can populate relationships.
+    const models = modelsRaw.map((dmmfModel) => parseModelCore({ dmmfModel, config }));
+    const enums = enumsRaw.map((dmmfEnum) => parseEnum({ dmmfEnum, config }));
+    const modelsWithFields = modelsRaw
+        .map((dmmfModel) => parseModel({ dmmfModel, models, enums, config }))
+        .filter((model) => !model.attributes.ignore);
+    return { models: modelsWithFields, enums };
+}
+exports.parsePrismaSchema = parsePrismaSchema;
+/**
+ * Parses the core properties of a model without fields.
+ */
+function parseModelCore({ dmmfModel, config, }) {
+    const attributes = (0, attributes_1.getModelAttributes)(dmmfModel);
+    return {
+        name: (0, string_1.toPascalCase)(dmmfModel.name),
+        description: attributes.description,
+        typeName: Types.toTypeName((0, string_1.toPascalCase)(dmmfModel.name)),
+        sourceName: dmmfModel.name,
+        brandedIdType: Types.toTypeName(`${(0, string_1.toPascalCase)(dmmfModel.name)}Id`),
+        attributes,
+        schemaConfig: config,
+    };
+}
+/**
+ * Converts a preprocessed model (with DMMF model) to a complete Schema.Model
+ * by extracting/converting fields from DMMF and attaching them to the model
+ */
+function parseModel({ dmmfModel, enums, models, config, }) {
+    const core = parseModelCore({ dmmfModel, config });
+    // NOTE: We assume that each relation may only reference one field. Because of this,
+    // we can "relate" a given relation to a scalar field used in the relation.
+    //   Since Prisma doesn't mark those fields as relations, we need to preprocess
+    // relations and then figure out which scalar fields are used in relations.
+    const relations = {};
+    for (const dmmfField of dmmfModel.fields) {
+        if (dmmfField.kind !== 'object' ||
+            !dmmfField.relationName ||
+            !dmmfField.relationFromFields ||
+            !dmmfField.relationToFields) {
+            continue;
+        }
+        if (dmmfField.relationFromFields.length > 1) {
+            throw new Error(`❌❌❌ Relation ${dmmfField.relationName} has more than one from field`);
+        }
+        const referencedModel = models.find((m) => m.sourceName === dmmfField.type);
+        if (!referencedModel) {
+            (0, error_1.throwError)(`Investigate: Field references unknown model ${dmmfField.type}.`);
+        }
+        relations[dmmfField.relationFromFields[0]] = referencedModel;
+    }
+    const fields = dmmfModel.fields
+        .filter((dmmfField) => 
+    // if field is a "backlink", i.e. the reciever of a relation, we ignore it
+    dmmfField.kind !== 'object')
+        .map((dmmfField) => {
+        const attributes = (0, attributes_1.getFieldAttributes)(dmmfField);
+        const shared = {
+            name: (0, string_1.toCamelCase)(dmmfField.name),
+            description: attributes.description,
+            sourceName: dmmfField.name,
+            isRequired: dmmfField.isRequired,
+            attributes,
+            schemaConfig: config,
+        };
+        // NOTE: We mark scalar fields which are used in relations as relation fields by Purple Schema standards.
+        if (dmmfField.name in relations) {
+            const refModel = relations[dmmfField.name];
+            return Object.assign(Object.assign({ kind: 'relation' }, shared), { typeName: Types.toTypeName(dmmfField.type), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
+        }
+        if (dmmfField.isId) {
+            return Object.assign(Object.assign({ kind: 'id' }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isAutoIncrementField(dmmfField), unbrandedTypeName: getTsTypeForId(dmmfField), model: core });
+        }
+        if (dmmfField.kind === 'scalar') {
+            let validation = undefined;
+            if (dmmfField.type === 'Int') {
+                validation = { type: 'int' };
+            }
+            if (dmmfField.type === 'Float') {
+                validation = { type: 'float' };
+            }
+            return Object.assign(Object.assign({ kind: 'scalar' }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isAutoIncrementField(dmmfField), typeName: getTsTypeForScalar(dmmfField) });
+        }
+        if (dmmfField.kind === 'enum') {
+            const fieldEnumDef = enums.find((e) => e.sourceName === dmmfField.type);
+            if (!fieldEnumDef) {
+                (0, error_1.throwError)(`Investigate: Field references unknown enum ${dmmfField.type}.`);
+            }
+            return Object.assign(Object.assign({ kind: 'enum' }, shared), { typeName: getTsTypeForEnum(dmmfField), enumerator: fieldEnumDef });
+        }
+        (0, error_1.throwError)(`Investigate: Field ${shared.sourceName}.${shared.sourceName} is not scalar, enum nor relation.`);
+    })
+        .filter((field) => !isFieldIgnored({ field }));
+    const { idField, defaultField, nameField } = validateFields({ fields, model: core });
+    return Object.assign(Object.assign({}, core), { idField,
+        defaultField,
+        nameField,
+        fields });
+}
+/**
+ * Checks that there is exactly one id field and that there is at most one default field.
+ */
+function validateFields({ fields, model: { name } }) {
+    let idField = undefined;
+    let nameField = undefined;
+    let nameFieldFallback = undefined;
+    let defaultField = undefined;
+    for (const field of fields) {
+        switch (field.kind) {
+            case 'scalar':
+                if (field.name === 'name') {
+                    nameFieldFallback = field;
+                }
+                break;
+            case 'id':
+                if (idField) {
+                    throw new Error(`❌❌❌ Model ${name} has multiple id fields`);
+                }
+                idField = field;
+                break;
+            case 'relation':
+                break;
+            case 'enum':
+                break;
+        }
+        //handle default case
+        if (Object.hasOwn(field.attributes, 'isDefault') && field.kind === 'scalar') {
+            if (defaultField !== undefined) {
+                throw new Error(`❌❌❌ Model ${name} has multiple default fields`);
+            }
+            defaultField = field;
+        }
+        //handle name field
+        if ((Object.hasOwn(field.attributes, 'name') || Object.hasOwn(field.attributes, 'label')) &&
+            field.kind === 'scalar') {
+            if (name !== undefined) {
+                throw new Error(`❌❌❌ Model ${name} has multiple name fields`);
+            }
+            nameField = field;
+        }
+    }
+    if (!idField) {
+        throw new Error(`❌❌❌ Model ${name} does not have an id field`);
+    }
+    if (!nameField && nameFieldFallback) {
+        nameField = nameFieldFallback;
+    }
+    return { idField, defaultField, nameField };
+}
+function isAutoIncrementField(fieldDmmf) {
+    const d = fieldDmmf.default;
+    return d !== undefined && !!d.name && d.name === 'autoincrement';
+}
+function isUniqueField(fieldRaw) {
+    return fieldRaw.isUnique && fieldRaw.type === 'String';
+}
+/**
+ * Tells whether the parsed schema should skip a given field.
+ */
+function isFieldIgnored({ field }) {
+    if (field.name === 'createdAt' || field.name === 'updatedAt' || field.name === 'deletedAt') {
+        return true;
+    }
+    if (Object.hasOwn(field.attributes, 'ignore') && field.attributes.ignore) {
+        return true;
+    }
+    if (field.kind === 'relation' && field.relationToModel.attributes.ignore) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Parses a given enumerator type.
+ */
+function parseEnum({ dmmfEnum, config }) {
+    return {
+        name: dmmfEnum.name,
+        typeName: Types.toTypeName((0, string_1.toPascalCase)(dmmfEnum.name)),
+        sourceName: dmmfEnum.name,
+        values: dmmfEnum.values.map((v) => v.name),
+        schemaConfig: config,
+    };
+}
+/**
+ * Returns the TypeScript type of a scalar database field
+ */
+function getTsTypeForScalar(field) {
+    switch (field.type) {
+        case 'BigInt':
+        case 'String':
+            return Types.toTypeName('string');
+        case 'Boolean':
+            return Types.toTypeName('boolean');
+        case 'DateTime':
+            return Types.toTypeName('Date');
+        case 'Decimal':
+        case 'Float':
+        case 'Int':
+            return Types.toTypeName('number');
+        case 'JSON':
+        case 'Bytes':
+            (0, error_1.throwError)('Not implemented yet');
+        default:
+            // return field.type
+            (0, error_1.throwError)(`Investigate: 'default' case in getTypescriptType for field ${field.name} of type ${field.type}`);
+    }
+}
+/**
+ * Returns the TypeScript type of a scalar id field.
+ */
+function getTsTypeForId(field) {
+    switch (field.type) {
+        case 'BigInt':
+        case 'String':
+            return Types.toTypeName('string');
+        case 'Boolean':
+            return Types.toTypeName('boolean');
+        case 'Decimal':
+        case 'Float':
+        case 'Int':
+            return Types.toTypeName('number');
+        default:
+            (0, error_1.throwError)(`The id field ${field.name}  is of type ${field.type} - but only BigInt, Boolean, Decimal, Float, Int and String are supported for Ids.`);
+    }
+}
+/**
+ * Returns the TypeScript type of an enum field.
+ */
+function getTsTypeForEnum(field) {
+    switch (field.type) {
+        case 'String':
+            return Types.toTypeName('string');
+        case 'BigInt':
+        case 'Boolean':
+        case 'Decimal':
+        case 'Float':
+        case 'Int':
+            (0, error_1.throwError)(`The enum field ${field.name}  is of type ${field.type} - but only String fields are supported for enums so far.`);
+        default:
+            return Types.toTypeName(field.type);
+    }
+}

package/dist/tests/attributes.test.d.ts

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

package/dist/tests/attributes.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const attributes_1 = require("../src/prisma/attributes");
+describe('argument parser', () => {
+    test('Blank argument should return blank string', () => {
+        expect((0, attributes_1.parseArgumentToStringOrStringArray)('')).toEqual('');
+    });
+    test('Argument without quotes should return as is', () => {
+        expect((0, attributes_1.parseArgumentToStringOrStringArray)('example')).toEqual('example');
+    });
+    test('Argument with quotes should return without quotes', () => {
+        expect((0, attributes_1.parseArgumentToStringOrStringArray)('"example"')).toEqual('example');
+    });
+    test('Argument with escaped quotes should return without quotes', () => {
+        expect((0, attributes_1.parseArgumentToStringOrStringArray)('"example \\"with quotes\\""')).toEqual('example "with quotes"');
+    });
+    test('Argument with array of strings should convert to array', () => {
+        expect((0, attributes_1.parseArgumentToStringOrStringArray)('["example1", "example2"]')).toEqual(['example1', 'example2']);
+    });
+});
+describe('attribute parser', () => {
+    test('Missing documentation should return blank object', () => {
+        expect((0, attributes_1.parseAttributesFromDocumentation)({})).toEqual({});
+    });
+    test('Entries without "@@" should be ignored', () => {
+        expect((0, attributes_1.parseAttributesFromDocumentation)({ documentation: 'Some documentation' })).toEqual({});
+    });
+    test('Entries with "@@" should be parsed', () => {
+        expect((0, attributes_1.parseAttributesFromDocumentation)({ documentation: '@@ignore()' })).toEqual({ ignore: '' });
+    });
+    test('Attributes should be converted to camelCase', () => {
+        expect((0, attributes_1.parseAttributesFromDocumentation)({ documentation: '@@IGNORE()' })).toEqual({ iGNORE: '' });
+    });
+});
+describe('model attribute: ignore', () => {
+    test('should default to false', () => {
+        expect((0, attributes_1.getModelAttributes)({}).ignore).toBe(false);
+        expect((0, attributes_1.getModelAttributes)({ documentation: '' }).ignore).toBe(false);
+        expect((0, attributes_1.getModelAttributes)({ documentation: '@@test()' }).ignore).toBe(false);
+    });
+    test('should be true if @@ignore attribute is provided', () => {
+        expect((0, attributes_1.getModelAttributes)({ documentation: '@@ignore()' }).ignore).toBe(true);
+    });
+});
+describe('field attribute: ignore', () => {
+    test('should default to false', () => {
+        expect((0, attributes_1.getFieldAttributes)({}).ignore).toBe(false);
+        expect((0, attributes_1.getFieldAttributes)({ documentation: '' }).ignore).toBe(false);
+        expect((0, attributes_1.getFieldAttributes)({ documentation: '@@test()' }).ignore).toBe(false);
+    });
+    test('should be true if @@ignore attribute is provided', () => {
+        expect((0, attributes_1.getFieldAttributes)({ documentation: '@@ignore()' }).ignore).toBe(true);
+    });
+    test('should be true if Prisma field has isIgnored flag set to true', () => {
+        expect((0, attributes_1.getFieldAttributes)({ isIgnored: true }).ignore).toBe(true);
+    });
+});
+describe('field attributes: example and examples', () => {
+    test('should default to undefined', () => {
+        expect((0, attributes_1.getFieldAttributes)({}).examples).toBe(undefined);
+    });
+    test('should parse "@@examples" attribute', () => {
+        expect((0, attributes_1.getFieldAttributes)({ documentation: '@@examples("test")' }).examples).toStrictEqual(['test']);
+    });
+    test('should parse "@@example" attribute', () => {
+        expect((0, attributes_1.getFieldAttributes)({ documentation: '@@example("test")' }).examples).toStrictEqual(['test']);
+    });
+    test('should give precedence to "@@examples" over "@@example" attribute', () => {
+        expect((0, attributes_1.getFieldAttributes)({ documentation: '@@example("B")\n@@examples("A")' }).examples).toStrictEqual([
+            'A',
+        ]);
+    });
+    test('should parse "@@example" attribute with an array of examples', () => {
+        expect((0, attributes_1.getFieldAttributes)({ documentation: '@@example("A", "B")' }).examples).toStrictEqual(['A', 'B']);
+    });
+});

package/dist/tests/file.test.d.ts

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

package/dist/tests/file.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_1 = require("../src/lib/utils/file");
+describe('virtual file system', () => {
+    test('correctly resolves path to the same file', () => {
+        expect((0, file_1.getRelativePath)({ from: 'a/b/c', to: 'a/b/c' })).toEqual('./c');
+    });
+    test('correctly resolves path to a file in the same folder', () => {
+        expect((0, file_1.getRelativePath)({ from: 'a/b/c', to: 'a/b/d' })).toEqual('./d');
+    });
+    test('correclty, resolves path to a file in a parent folder', () => {
+        expect((0, file_1.getRelativePath)({ from: 'a/b/c', to: 'a/d' })).toEqual('../d');
+    });
+    test('correctly resolves completely different paths', () => {
+        expect((0, file_1.getRelativePath)({ from: 'a/b/c', to: 'd/e/f' })).toEqual('../../d/e/f');
+    });
+    test('correctly resolves path to a package', () => {
+        expect((0, file_1.getRelativePath)({ from: 'a/b/c', to: '@lib/package' })).toEqual('@lib/package');
+    });
+    test('correctly resolves relative paths', () => {
+        expect((0, file_1.getRelativePath)({
+            from: './backend/libs/data/src/services/data.module',
+            to: './backend/libs/data/src/repositories/country.repository',
+        })).toEqual('../repositories/country.repository');
+    });
+});

package/dist/tests/utils/random.d.ts

@@ -0,0 +1,3 @@
+export declare namespace RandomUtils {
+    function generateRandomAlphaNumericString(len: number): string;
+}

package/dist/tests/utils/random.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomUtils = void 0;
+const ALPHANUMERIC_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+var RandomUtils;
+(function (RandomUtils) {
+    function generateRandomAlphaNumericString(len) {
+        let text = '';
+        for (let i = 0; i < len; i++) {
+            text += ALPHANUMERIC_CHARS.charAt(Math.floor(Math.random() * ALPHANUMERIC_CHARS.length));
+        }
+        return text;
+    }
+    RandomUtils.generateRandomAlphaNumericString = generateRandomAlphaNumericString;
+})(RandomUtils = exports.RandomUtils || (exports.RandomUtils = {}));

package/dist/tests/vfs.test.d.ts

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

package/dist/tests/vfs.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vfs_1 = require("../src/lib/vfs");
+const random_1 = require("./utils/random");
+function adjustPathToOS(path) {
+    return path.replace(/\//g, process.platform === 'win32' ? '\\' : '/');
+}
+describe('virtual file system', () => {
+    test('IO works', () => {
+        const vfs = new vfs_1.VirtualFS();
+        const files = [];
+        for (let depth = 0; depth < 100; depth++) {
+            const path = '/folder'.repeat(depth) + '/file.txt';
+            const content = random_1.RandomUtils.generateRandomAlphaNumericString(160);
+            const status = vfs.write(path, content);
+            expect(status.ok).toBeTruthy();
+            files.push({ path, content });
+        }
+        for (const { path, content } of files) {
+            const file = vfs.read(path);
+            expect(file).toEqual({ ok: true, content });
+        }
+    });
+    test('lists files correctly', () => {
+        const vfs = new vfs_1.VirtualFS();
+        vfs.write('/a.txt', 'a');
+        vfs.write('/b.txt', 'b');
+        vfs.write('/c.txt', 'c');
+        vfs.write('/sub/a.txt', 'a');
+        vfs.write('/sub/b.txt', 'b');
+        vfs.write('/sub/c.txt', 'c');
+        const files = vfs.list('/');
+        const subFiles = vfs.list('/sub');
+        expect(files).toHaveLength(4);
+        expect(files).toContainEqual({ kind: 'FILE', name: 'a.txt' });
+        expect(files).toContainEqual({ kind: 'FILE', name: 'b.txt' });
+        expect(files).toContainEqual({ kind: 'FILE', name: 'c.txt' });
+        expect(files).toContainEqual({ kind: 'FOLDER', name: 'sub' });
+        expect(subFiles).toHaveLength(3);
+        expect(subFiles).toContainEqual({ kind: 'FILE', name: 'a.txt' });
+        expect(subFiles).toContainEqual({ kind: 'FILE', name: 'b.txt' });
+        expect(subFiles).toContainEqual({ kind: 'FILE', name: 'c.txt' });
+    });
+    test('lists folders correctly', () => {
+        const vfs = new vfs_1.VirtualFS();
+        vfs.write('/a/b/a/file.txt', 'a');
+        vfs.write('/a/b/b/file.txt', 'b');
+        vfs.write('/a/b/c/file.txt', 'c');
+        vfs.write('/a/b/d/file.txt', 'd');
+        const folders = vfs.list('/a/b');
+        expect(folders).toHaveLength(4);
+        expect(folders).toContainEqual({ kind: 'FOLDER', name: 'a' });
+        expect(folders).toContainEqual({ kind: 'FOLDER', name: 'b' });
+        expect(folders).toContainEqual({ kind: 'FOLDER', name: 'c' });
+        expect(folders).toContainEqual({ kind: 'FOLDER', name: 'd' });
+    });
+    test('copies files correctly', () => {
+        const vfs = new vfs_1.VirtualFS();
+        const src = new vfs_1.VirtualFS();
+        src.write('/a.txt', 'a');
+        src.write('/b.txt', 'b');
+        src.write('/c.txt', 'c');
+        vfs.copy(src, '/');
+        vfs.copy(src, '/sub');
+        expect(vfs.files()).toEqual({
+            [adjustPathToOS('/a.txt')]: 'a',
+            [adjustPathToOS('/b.txt')]: 'b',
+            [adjustPathToOS('/c.txt')]: 'c',
+            [adjustPathToOS('/sub/a.txt')]: 'a',
+            [adjustPathToOS('/sub/b.txt')]: 'b',
+            [adjustPathToOS('/sub/c.txt')]: 'c',
+        });
+    });
+});