@goatlab/fluent-formio 0.6.2 → 0.6.5

package/dist/FormioConnector.d.ts

@@ -0,0 +1,37 @@
+import type { Filter, BaseDataElement, PaginatedData, Paginator, Sure } from '@goatlab/fluent';
+import { BaseConnector, FluentConnectorInterface } from '@goatlab/fluent';
+interface IFormioConnector {
+    baseEndPoint: string;
+    token?: string;
+}
+export declare class Formioconnector<ModelDTO = BaseDataElement, InputDTO = ModelDTO, OutputDTO = ModelDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<InputDTO, OutputDTO> {
+    private baseEndPoint;
+    private authToken;
+    constructor({ baseEndPoint, token }: IFormioConnector);
+    get(): Promise<OutputDTO[]>;
+    all(): Promise<OutputDTO[]>;
+    find(filter: Filter): Promise<OutputDTO[]>;
+    paginate(paginator: Paginator): Promise<PaginatedData<OutputDTO>>;
+    insert(data: InputDTO): Promise<OutputDTO>;
+    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
+    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
+    truncate({ sure }: Sure): Promise<void>;
+    deleteById(id: string): Promise<string>;
+    findById(id: string): Promise<OutputDTO>;
+    private numberOfRows;
+    private getToken;
+    private getUrl;
+    private getHeaders;
+    private getSpacer;
+    private httpGET;
+    private httpPOST;
+    private httpPUT;
+    private httpDelete;
+    private getTokenType;
+    private getFilters;
+    private getLimit;
+    private getSkip;
+    private getOrder;
+    private getSelect;
+}
+export {};

package/dist/FormioConnector.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formioconnector = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+const isSameOrAfter_1 = tslib_1.__importDefault(require("dayjs/plugin/isSameOrAfter"));
+const jwt_decode_1 = tslib_1.__importDefault(require("jwt-decode"));
+const await_to_js_1 = tslib_1.__importDefault(require("await-to-js"));
+const js_utils_1 = require("@goatlab/js-utils");
+const fluent_1 = require("@goatlab/fluent");
+dayjs_1.default.extend(isSameOrAfter_1.default);
+const GoatExtenderAttributes = [
+    'id',
+    'owner',
+    'roles',
+    'created',
+    'modified',
+    '_ngram'
+];
+class Formioconnector extends fluent_1.BaseConnector {
+    constructor({ baseEndPoint, token }) {
+        super();
+        this.baseEndPoint = '';
+        this.authToken = '';
+        this.baseEndPoint = baseEndPoint;
+        this.authToken = token;
+    }
+    async get() {
+        const [error, result] = await (0, await_to_js_1.default)(this.httpGET());
+        if (error) {
+            console.log(error);
+            throw new Error('Error while getting submissions');
+        }
+        const data = result.data.map(r => {
+            const response = {
+                ...{
+                    id: r.id,
+                    owner: r.owner,
+                    roles: r.roles,
+                    created: r.created,
+                    modified: r.modified
+                },
+                ...r.data
+            };
+            return response;
+        });
+        let orderedResults = this.jsApplySelect(data);
+        orderedResults = this.jsApplyOrderBy(orderedResults);
+        this.reset();
+        return orderedResults;
+    }
+    async all() {
+        return this.get();
+    }
+    async find(filter) {
+        return this.get();
+    }
+    async paginate(paginator) {
+        const numberOfRows = await this.numberOfRows();
+        this.offset((paginator.page - 1) * paginator.perPage).take(paginator.perPage);
+        const results = {
+            data: await this.get(),
+            current_page: paginator.page,
+            first_page_url: '',
+            prev_page_url: '',
+            next_page_url: '',
+            per_page: paginator.perPage,
+            path: '',
+            total: Number(numberOfRows)
+        };
+        this.reset();
+        return results;
+    }
+    async insert(data) {
+        const [error, result] = await (0, await_to_js_1.default)(this.httpPOST(data));
+        if (error) {
+            console.log(error);
+            throw new Error('Cannot insert data');
+        }
+        const response = {
+            ...{
+                id: result.data.id,
+                owner: result.data.owner,
+                roles: result.data.roles,
+                created: result.data.created,
+                modified: result.data.modified
+            },
+            ...result.data.data
+        };
+        this.reset();
+        return response;
+    }
+    async insertMany(data) {
+        const insertedElements = [];
+        for (const element of data) {
+            const inserted = await this.insert({
+                ...element
+            });
+            insertedElements.push(inserted);
+        }
+        this.reset();
+        return insertedElements;
+    }
+    async updateById(id, data) {
+        if (!id) {
+            throw new Error('Formio connector error. Cannot update a Model without id key');
+        }
+        if (id.includes('_local')) {
+            throw new Error('Formio connector error. Cannot update a local document');
+        }
+        const [error, result] = await (0, await_to_js_1.default)(this.httpPUT(id, data));
+        if (error) {
+            console.log(error);
+            throw new Error('Cannot insert data');
+        }
+        const response = result.data;
+        this.reset();
+        return response;
+    }
+    async truncate({ sure }) {
+    }
+    async deleteById(id) {
+        const [error, removed] = await (0, await_to_js_1.default)(this.httpDelete(id));
+        if (error) {
+            console.log(error);
+            throw new Error(`FormioConnector: Could not delete ${id}`);
+        }
+        this.reset();
+        return removed.data;
+    }
+    async findById(id) {
+        const [error, data] = await (0, await_to_js_1.default)(this.first());
+        if (error) {
+            console.log(error);
+            throw new Error('Find() could not get remote data');
+        }
+        this.reset();
+        return data;
+    }
+    async numberOfRows() {
+        let url = this.getUrl();
+        const headers = this.getHeaders();
+        const filters = this.getFilters();
+        const limit = '?limit=1';
+        const skip = this.getSkip();
+        const order = this.getOrder();
+        const select = this.getSelect();
+        const spacer = '';
+        url = url + spacer + limit;
+        url = filters ? url + this.getSpacer(url) + filters : url;
+        url = skip ? url + this.getSpacer(url) + skip : url;
+        url = order ? url + this.getSpacer(url) + order : url;
+        url = select ? url + this.getSpacer(url) + select : url;
+        const isOnline = true;
+        if (!isOnline) {
+            throw new Error(`Cannot make get request to ${url}.You are not online`);
+        }
+        const response = await axios_1.default.get(url, { headers });
+        return response.headers['content-range'].split('/')[1];
+    }
+    getToken() {
+        if (typeof localStorage === 'undefined') {
+            return;
+        }
+        const token = localStorage.getItem('formioToken');
+        if (!token || this.getTokenType(token) === 'x-jwt-token') {
+            return token;
+        }
+        const decodedToken = (0, jwt_decode_1.default)(token);
+        const expDate = dayjs_1.default.unix(decodedToken.exp);
+        if ((0, dayjs_1.default)().isSameOrAfter(expDate)) {
+            js_utils_1.Events.emit('GOAT:SESSION:EXPIRED', {
+                data: expDate,
+                text: 'Session expired'
+            });
+            throw new Error('Token has expired.');
+        }
+        return token;
+    }
+    getUrl() {
+        const baseUrl = `${this.baseEndPoint}/submission`;
+        return baseUrl;
+    }
+    getHeaders() {
+        const headers = {};
+        let token = {};
+        if (typeof localStorage !== 'undefined') {
+            token = this.getToken();
+        }
+        if (this.authToken || this.authToken === '') {
+            token = this.authToken;
+        }
+        if (!token) {
+            return headers;
+        }
+        const type = this.getTokenType(token);
+        headers[type] = token;
+        return headers;
+    }
+    getSpacer(url) {
+        return url.substr(url.length - 1) === '&' ? '' : '&';
+    }
+    async httpGET() {
+        let url = this.getUrl();
+        const headers = this.getHeaders();
+        const filters = this.getFilters();
+        const limit = this.getLimit();
+        const skip = this.getSkip();
+        const order = this.getOrder();
+        const select = this.getSelect();
+        const spacer = '';
+        url = url + spacer + limit;
+        url = filters ? url + this.getSpacer(url) + filters : url;
+        url = skip ? url + this.getSpacer(url) + skip : url;
+        url = order ? url + this.getSpacer(url) + order : url;
+        url = select ? url + this.getSpacer(url) + select : url;
+        const isOnline = true;
+        if (!isOnline) {
+            throw new Error(`Cannot make get request to ${url}.You are not online`);
+        }
+        return axios_1.default.get(url, { headers });
+    }
+    async httpPOST(data) {
+        const url = this.getUrl();
+        const headers = this.getHeaders();
+        const isOnline = true;
+        if (!isOnline) {
+            throw new Error(`Cannot make request post to ${url}.You are not online`);
+        }
+        return axios_1.default.post(url, { data }, { headers });
+    }
+    async httpPUT(id, data) {
+        const isOnline = true;
+        const url = `${this.getUrl()}/${id}`;
+        const headers = this.getHeaders();
+        if (!isOnline) {
+            throw new Error(`Cannot make request post to ${url}.You are not online`);
+        }
+        return axios_1.default.put(url, { data }, { headers });
+    }
+    httpDelete(id) {
+        const headers = this.getHeaders();
+        const url = `${this.getUrl()}/${id}`;
+        return axios_1.default.delete(url, { headers });
+    }
+    getTokenType(token) {
+        return token.length > 32 ? 'x-jwt-token' : 'x-token';
+    }
+    getFilters() {
+        const filter = this.whereArray;
+        if (!filter || filter.length === 0) {
+            return undefined;
+        }
+        let filterQuery = '';
+        filter.forEach(condition => {
+            let valueString = '';
+            const element = GoatExtenderAttributes.includes(condition[0])
+                ? condition[0]
+                : `data.${condition[0]}`;
+            const operator = condition[1];
+            const value = condition[2];
+            switch (operator) {
+                case '=':
+                    filterQuery = `${filterQuery + element}=${value}&`;
+                    break;
+                case '!=':
+                    filterQuery = `${filterQuery + element}__ne=${value}&`;
+                    break;
+                case '>':
+                    filterQuery = `${filterQuery + element}__gt=${value}&`;
+                    break;
+                case '>=':
+                    filterQuery = `${filterQuery + element}__gte=${value}&`;
+                    break;
+                case '<':
+                    filterQuery = `${filterQuery + element}__lt=${value}&`;
+                    break;
+                case '<=':
+                    filterQuery = `${filterQuery + element}__lte=${value}&`;
+                    break;
+                case 'in':
+                    valueString = '';
+                    value.forEach((val, index, array) => {
+                        valueString =
+                            index === array.length - 1
+                                ? valueString + val
+                                : `${valueString + val},`;
+                    });
+                    filterQuery = `${filterQuery + element}__in=${valueString}&`;
+                    break;
+                case 'nin':
+                    valueString = '';
+                    value.forEach((val, index, array) => {
+                        valueString =
+                            index === array.length - 1
+                                ? valueString + val
+                                : `${valueString + val},`;
+                    });
+                    filterQuery = `${filterQuery + element}__nin=${valueString}&`;
+                    break;
+                case 'exists':
+                    filterQuery = `${filterQuery + element}__exists=${true}&`;
+                    break;
+                case '!exists':
+                    filterQuery = `${filterQuery + element}__exists=${false}&`;
+                    break;
+                case 'regex':
+                    filterQuery = `${filterQuery + element}__regex=${value}&`;
+                    break;
+            }
+        });
+        return filterQuery.substring(0, filterQuery.length - 1);
+    }
+    getLimit() {
+        const limit = '?limit=';
+        if (!this.limitNumber || this.limitNumber === 0) {
+            this.limitNumber = 50;
+        }
+        return `${limit}${this.limitNumber}`;
+    }
+    getSkip() {
+        const skip = 'skip=';
+        if (!this.offsetNumber) {
+            this.offsetNumber = 0;
+        }
+        return skip + this.offsetNumber;
+    }
+    getOrder() {
+        const order = 'sort=';
+        const or = this.orderByArray[1] === 'DESC' ? '-' : '';
+        return order + or + this.orderByArray[0];
+    }
+    getSelect() {
+        let select = this.selectArray;
+        select = select.map(e => e.split(' as ')[0]);
+        if (!select) {
+            return;
+        }
+        select = select.map(e => GoatExtenderAttributes.includes(e) ? e : `data.${e}`);
+        return `select=${select.join(',')}`;
+    }
+}
+exports.Formioconnector = Formioconnector;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { Formioconnector } from './FormioConnector';
+export { Formioconnector };

package/dist/test/advanced/advancedTestSuite.d.ts

@@ -0,0 +1 @@
+export declare const advancedTestSuite: (Model: any) => void;

package/dist/test/advanced/advancedTestSuite.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.advancedTestSuite = void 0;
+const advancedTestSuite = Model => {
+    beforeAll(() => {
+        try {
+            Model = new Model();
+        }
+        catch (error) { }
+    });
+    const insertTestData = async (Repository) => {
+        await Repository.insert({
+            created: '2018-12-03',
+            nestedTest: {
+                a: [6, 5, 4],
+                b: { c: true, d: [2, 1, 0] },
+                c: 4
+            },
+            order: 1,
+            test: true
+        });
+        await Repository.insert({
+            created: '2017-12-03',
+            nestedTest: {
+                a: [3, 2, 1],
+                b: { c: true, d: [1, 1, 0] },
+                c: 3
+            },
+            order: 2,
+            test: false
+        });
+        await Repository.insert({
+            created: '2016-12-03',
+            nestedTest: {
+                a: [0, -1, -2],
+                b: { c: true, d: [0, 1, 0] },
+                c: 2
+            },
+            order: 3,
+            test: false
+        });
+    };
+    it('Should get local data', async () => {
+        await insertTestData(Model);
+        const data = await Model.all();
+        expect(Array.isArray(data)).toBe(true);
+        expect(typeof data[0].nestedTest.b.c).toBe('boolean');
+    });
+    it('pluck() should return a single array', async () => {
+        await insertTestData(Model);
+        const data = await Model.pluck(Model._keys.test);
+        expect(typeof data[0]).toBe('boolean');
+    });
+    it('orderBy() should order results desc', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.test, Model._keys.nestedTest.b.c, Model._keys.order)
+            .orderBy(Model._keys.order, 'desc')
+            .get();
+        expect(forms[0].order).toBe(3);
+        expect(forms[0].nestedTest.b.c).toBe(true);
+    });
+    it('orderBy() should order results asc', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.test, Model._keys.nestedTest.b.c, Model._keys.order)
+            .orderBy(Model._keys.order, 'asc')
+            .get();
+        expect(forms[0].order).toBe(1);
+    });
+    it('orderBy() should order by Dates with Select()', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.created, Model._keys.order)
+            .orderBy(Model._keys.created, 'asc', 'date')
+            .get();
+        expect(forms[0].order).toBe(3);
+    });
+    it('orderBy() should order by Dates without Select()', async () => {
+        await insertTestData(Model);
+        const forms = await Model.orderBy(Model._keys.created, 'asc', 'date').get();
+        expect(forms[0].order).toBe(3);
+    });
+    it('limit() should limit the amount of results', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.created, Model._keys.order)
+            .orderBy(Model._keys.created, 'asc', 'date')
+            .limit(2)
+            .get();
+        expect(forms.length > 0).toBe(true);
+        expect(forms.length <= 2).toBe(true);
+    });
+    it('offset() should start at the given position', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.created, Model._keys.order)
+            .offset(1)
+            .limit(1)
+            .get();
+        expect(forms.length).toBe(1);
+    });
+    it('where() should filter the data', async () => {
+        await insertTestData(Model);
+        const forms = await Model.where(Model._keys.nestedTest.c, '>=', 3).get();
+        expect(forms.length > 0).toBe(true);
+        forms.forEach(form => {
+            expect(form.nestedTest.c >= 3).toBe(true);
+        });
+    });
+    it('first() should take the first result from data', async () => {
+        await insertTestData(Model);
+        const form = await Model.select(Model._keys.nestedTest.c, Model._keys.id)
+            .where(Model._keys.nestedTest.c, '>=', 3)
+            .first();
+        expect(typeof form.nestedTest.c).toBe('number');
+    });
+};
+exports.advancedTestSuite = advancedTestSuite;

package/dist/test/advanced/typeOrm.entity.d.ts

@@ -0,0 +1,16 @@
+export declare class FurtherNested {
+    c: boolean;
+    d: number[];
+}
+export declare class Nested {
+    a: number[];
+    c: number;
+    b?: FurtherNested;
+}
+export declare class TypeORMDataModel {
+    id: string;
+    created?: string;
+    nestedTest?: Nested;
+    order?: number;
+    test: boolean;
+}

package/dist/test/advanced/typeOrm.entity.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMDataModel = exports.Nested = exports.FurtherNested = void 0;
+const tslib_1 = require("tslib");
+const fluent_1 = require("@goatlab/fluent");
+class FurtherNested {
+}
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: true }),
+    tslib_1.__metadata("design:type", Boolean)
+], FurtherNested.prototype, "c", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.array({ required: true }),
+    tslib_1.__metadata("design:type", Array)
+], FurtherNested.prototype, "d", void 0);
+exports.FurtherNested = FurtherNested;
+class Nested {
+}
+tslib_1.__decorate([
+    fluent_1.Decorators.array({ required: true }),
+    tslib_1.__metadata("design:type", Array)
+], Nested.prototype, "a", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: true }),
+    tslib_1.__metadata("design:type", Number)
+], Nested.prototype, "c", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.embed(FurtherNested),
+    tslib_1.__metadata("design:type", FurtherNested)
+], Nested.prototype, "b", void 0);
+exports.Nested = Nested;
+let TypeORMDataModel = class TypeORMDataModel {
+};
+tslib_1.__decorate([
+    fluent_1.Decorators.id(),
+    tslib_1.__metadata("design:type", String)
+], TypeORMDataModel.prototype, "id", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: false }),
+    tslib_1.__metadata("design:type", String)
+], TypeORMDataModel.prototype, "created", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.embed(Nested),
+    tslib_1.__metadata("design:type", Nested)
+], TypeORMDataModel.prototype, "nestedTest", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: false }),
+    tslib_1.__metadata("design:type", Number)
+], TypeORMDataModel.prototype, "order", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: true }),
+    tslib_1.__metadata("design:type", Boolean)
+], TypeORMDataModel.prototype, "test", void 0);
+TypeORMDataModel = tslib_1.__decorate([
+    fluent_1.Decorators.entity('numbers')
+], TypeORMDataModel);
+exports.TypeORMDataModel = TypeORMDataModel;

package/dist/test/advanced/typeOrm.repository.d.ts

@@ -0,0 +1,5 @@
+import { TypeORMDataModel } from './typeOrm.entity';
+import { TypeOrmConnector } from '@goatlab/fluent';
+export declare class TypeOrmRepository extends TypeOrmConnector<TypeORMDataModel> {
+    constructor(relations?: any);
+}

package/dist/test/advanced/typeOrm.repository.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmRepository = void 0;
+const typeOrm_entity_1 = require("./typeOrm.entity");
+const fluent_1 = require("@goatlab/fluent");
+class TypeOrmRepository extends fluent_1.TypeOrmConnector {
+    constructor(relations) {
+        super(typeOrm_entity_1.TypeORMDataModel, relations, 'runningTest');
+    }
+}
+exports.TypeOrmRepository = TypeOrmRepository;

package/dist/test/basic/basicTestSuite.d.ts

@@ -0,0 +1 @@
+export declare const basicTestSuite: (Model: any) => void;

package/dist/test/basic/basicTestSuite.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicTestSuite = void 0;
+const flock_1 = require("../flock");
+const basicTestSuite = Model => {
+    let storedId;
+    beforeAll(() => {
+        Model = new Model();
+    });
+    test('Get - Should  GET data', async () => {
+        const storedGoats = await Model.get();
+        expect(Array.isArray(storedGoats)).toBe(true);
+    });
+    test('Insert - Should  insert data', async () => {
+        const a = await Model.insert({ name: 'myGoat', age: 13 });
+        expect(typeof a.id).toBe('string');
+        expect(a.name).toBe('myGoat');
+        expect(0).toBe(0);
+    });
+    it('Create Multiple - Should insert Multiple elements', async () => {
+        const insertedFlock = await Model.insertMany(flock_1.flock);
+        expect(insertedFlock[0].name).toBe('Goatee');
+        storedId = insertedFlock[0].id;
+    });
+    it('UpdateById - Should Update a single element', async () => {
+        await Model.insertMany(flock_1.flock);
+        const goats = await Model.get();
+        const data = await Model.updateById(goats[0].id, {
+            age: 99,
+            name: 'MyUpdatedGoat'
+        });
+        expect(data.name).toBe('MyUpdatedGoat');
+        expect(data.id).toBe(goats[0].id);
+    });
+    it('ReplaceById - Should Update a single element', async () => {
+        await Model.insertMany(flock_1.flock);
+        const goats = await Model.get();
+        const data = await Model.updateById(goats[0].id, {
+            name: 'MyUpdatedGoat'
+        });
+        expect(data.name).toBe('MyUpdatedGoat');
+        expect(data.id).toBe(goats[0].id);
+    });
+};
+exports.basicTestSuite = basicTestSuite;

package/dist/test/basic/goat.dto.d.ts

@@ -0,0 +1,8 @@
+import { GoatEntity } from './goat.entity';
+declare const GoatEntityOut_base: import("@goatlab/fluent/dist/core/Nestjs/types/common").Type<Omit<GoatEntity, never>>;
+export declare class GoatEntityOut extends GoatEntityOut_base {
+}
+declare const GoatEntityIn_base: import("@goatlab/fluent/dist/core/Nestjs/types/common").Type<Omit<GoatEntity, "id">>;
+export declare class GoatEntityIn extends GoatEntityIn_base {
+}
+export {};

package/dist/test/basic/goat.dto.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoatEntityIn = exports.GoatEntityOut = void 0;
+const tslib_1 = require("tslib");
+const goat_entity_1 = require("./goat.entity");
+const fluent_1 = require("@goatlab/fluent");
+let GoatEntityOut = class GoatEntityOut extends (0, fluent_1.OmitType)(goat_entity_1.GoatEntity, []) {
+};
+GoatEntityOut = tslib_1.__decorate([
+    (0, fluent_1.InputType)()
+], GoatEntityOut);
+exports.GoatEntityOut = GoatEntityOut;
+let GoatEntityIn = class GoatEntityIn extends (0, fluent_1.OmitType)(goat_entity_1.GoatEntity, ['id']) {
+};
+GoatEntityIn = tslib_1.__decorate([
+    (0, fluent_1.InputType)()
+], GoatEntityIn);
+exports.GoatEntityIn = GoatEntityIn;

package/dist/test/basic/goat.entity.d.ts

@@ -0,0 +1,10 @@
+export declare class Breed {
+    family?: string;
+    members?: number;
+}
+export declare class GoatEntity {
+    id: string;
+    name: string;
+    age?: number;
+    breed?: Breed;
+}