@memberjunction/server 6.2.0-edge.5 → 6.2.0-edge.7

package/src/__tests__/requestOrigin.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import { NormalizeOrigin, ReadRequestOrigin } from '../requestOrigin.js';
+import { IsOriginAllowed, ParseAllowedOrigins } from '../realtimeWidget/widgetCore.js';
+
+describe('NormalizeOrigin', () => {
+  it('trims, lowercases and strips trailing slashes', () => {
+    expect(NormalizeOrigin('  HTTPS://App.Example.COM//  ')).toBe('https://app.example.com');
+  });
+
+  it('keeps an explicit port, default or not', () => {
+    expect(NormalizeOrigin('https://a.com:443')).toBe('https://a.com:443');
+    expect(NormalizeOrigin('http://localhost:4200/')).toBe('http://localhost:4200');
+  });
+
+  it('returns a value made only of slashes as empty', () => {
+    expect(NormalizeOrigin('///')).toBe('');
+  });
+
+  it('handles a long run of slashes that is not at the end in linear time', () => {
+    const hostile = 'https://a.com' + '/'.repeat(100_000) + 'x';
+    const started = Date.now();
+    expect(NormalizeOrigin(hostile)).toBe(hostile);
+    expect(ReadRequestOrigin(hostile)).toBeUndefined();
+    expect(Date.now() - started).toBeLessThan(1000);
+  });
+});
+
+describe('ReadRequestOrigin', () => {
+  describe('origin present', () => {
+    it('returns the normalized origin', () => {
+      expect(ReadRequestOrigin('https://Embed.Example.com')).toBe('https://embed.example.com');
+    });
+
+    it('strips a trailing slash', () => {
+      expect(ReadRequestOrigin('https://embed.example.com/')).toBe('https://embed.example.com');
+    });
+
+    it('accepts an IPv6 host with a port', () => {
+      expect(ReadRequestOrigin('http://[::1]:3000')).toBe('http://[::1]:3000');
+    });
+  });
+
+  describe('origin absent', () => {
+    it('returns undefined for a missing header', () => {
+      expect(ReadRequestOrigin(undefined)).toBeUndefined();
+    });
+
+    it('returns undefined for a blank header', () => {
+      expect(ReadRequestOrigin('')).toBeUndefined();
+      expect(ReadRequestOrigin('   ')).toBeUndefined();
+    });
+
+    it('returns undefined for a repeated header', () => {
+      expect(ReadRequestOrigin(['https://a.com', 'https://b.com'])).toBeUndefined();
+    });
+  });
+
+  describe('origin malformed', () => {
+    it('returns undefined for the opaque "null" origin', () => {
+      expect(ReadRequestOrigin('null')).toBeUndefined();
+    });
+
+    it('returns undefined for a value that is not a URL', () => {
+      expect(ReadRequestOrigin('not an origin')).toBeUndefined();
+      expect(ReadRequestOrigin('https://')).toBeUndefined();
+    });
+
+    it('returns undefined for a non-http(s) scheme', () => {
+      expect(ReadRequestOrigin('file://')).toBeUndefined();
+      expect(ReadRequestOrigin('chrome-extension://abcdef')).toBeUndefined();
+    });
+
+    it('returns undefined when a path, query, fragment or credentials are present', () => {
+      expect(ReadRequestOrigin('https://a.com/path')).toBeUndefined();
+      expect(ReadRequestOrigin('https://a.com?x=1')).toBeUndefined();
+      expect(ReadRequestOrigin('https://a.com#frag')).toBeUndefined();
+      expect(ReadRequestOrigin('https://user:pw@a.com')).toBeUndefined();
+    });
+  });
+
+  describe('default ports', () => {
+    it('keeps an explicit default port as sent', () => {
+      expect(ReadRequestOrigin('https://a.com:443')).toBe('https://a.com:443');
+      expect(ReadRequestOrigin('http://a.com:80')).toBe('http://a.com:80');
+    });
+
+    it('keeps a non-default port', () => {
+      expect(ReadRequestOrigin('https://a.com:8443')).toBe('https://a.com:8443');
+    });
+
+    it('does not add a default port when none was sent', () => {
+      expect(ReadRequestOrigin('https://a.com')).toBe('https://a.com');
+    });
+  });
+
+  describe('agreement with the widget allowlist', () => {
+    it('a request origin matches the allowlist entry it was normalized against', () => {
+      const allowed = ParseAllowedOrigins('["https://Embed.Example.com/"]');
+      const origin = ReadRequestOrigin('https://embed.example.com');
+      expect(origin).toBe(allowed[0]);
+      expect(IsOriginAllowed(origin, allowed)).toBe(true);
+    });
+  });
+});

package/src/__tests__/resolverBase.cloudEventChangedFields.test.ts

@@ -0,0 +1,157 @@
+/**
+ * CloudEvents for an entity under field-level security carry the primary key and the names of the
+ * fields the save changed, never values.
+ *
+ * Driven by a REAL `BaseEntity` save rather than a stand-in object with `Dirty` set: a completed
+ * save rebases the object before it raises `save`, so nothing on it is dirty by the time a
+ * listener runs. The names must come from the event, which captures them before the rebase.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { cloudEventInits } = vi.hoisted(() => ({
+    cloudEventInits: [] as Array<Record<string, unknown>>,
+}));
+
+vi.mock('@memberjunction/sqlserver-dataprovider', () => ({ SQLServerDataProvider: class {} }));
+vi.mock('@memberjunction/generic-database-provider', () => ({ UserCache: { Users: [] } }));
+vi.mock('cloudevents', () => ({
+    CloudEvent: class {
+        constructor(init: Record<string, unknown>) {
+            cloudEventInits.push(init);
+            Object.assign(this, init);
+        }
+    },
+    httpTransport: () => () => undefined,
+    emitterFor: () => () => undefined,
+}));
+vi.mock('type-graphql', () => {
+    const noop = () => () => undefined;
+    return {
+        Resolver: noop, Mutation: noop, Query: noop, Subscription: noop, Ctx: noop, Arg: noop, PubSub: noop,
+        Root: noop, ObjectType: noop, InputType: noop, Field: noop, FieldResolver: noop,
+        Int: undefined, Float: undefined, registerEnumType: () => undefined,
+    };
+});
+vi.mock('graphql', () => ({ GraphQLError: class extends Error {} }));
+vi.mock('mssql', () => ({}));
+vi.mock('@memberjunction/api-keys', () => ({ GetAPIKeyEngine: vi.fn() }));
+vi.mock('@memberjunction/encryption', () => ({ EncryptionEngine: { Instance: {} } }));
+vi.mock('@memberjunction/graphql-dataprovider', () => ({ FieldMapper: class { MapFieldName(n: string) { return n; } ReverseMapFieldName(n: string) { return n; } } }));
+vi.mock('../generic/PubSubManager.js', () => ({ PubSubManager: { Instance: { Publish: () => undefined } } }));
+vi.mock('../generic/PushStatusResolver.js', () => ({ PUSH_STATUS_UPDATES_TOPIC: 'test-push-topic', PublishStatusUpdate: vi.fn() }));
+vi.mock('../generic/RunViewResolver.js', () => ({ RunViewByIDInput: class {}, RunViewByNameInput: class {}, RunDynamicViewInput: class {} }));
+vi.mock('../generic/DeleteOptionsInput.js', () => ({ DeleteOptionsInput: class {} }));
+vi.mock('../types.js', () => ({ RunViewGenericParams: class {} }));
+vi.mock('@memberjunction/core-entities', () => ({}));
+vi.mock('@memberjunction/core', async () => {
+    const actual = await vi.importActual<typeof import('@memberjunction/core')>('@memberjunction/core');
+    return { ...actual, LogError: vi.fn(), LogStatus: vi.fn(), LogDebug: vi.fn() };
+});
+
+import { BaseEntity, CompositeKey, EntityInfo, IEntityDataProvider, UserInfo } from '@memberjunction/core';
+import type { PubSubEngine } from 'type-graphql';
+import { ResolverBase } from '../generic/ResolverBase';
+import type { UserPayload } from '../types.js';
+import { EmployeeEntityInit, FullWidthEmployeeRow, HRUser, SECRET_SALARY } from './fieldSecurityFixtures.js';
+
+/** `Employees` with every field updatable through the API, so a real save can dirty them. */
+function updatableEmployees(withFls: boolean): EntityInfo {
+    const init = EmployeeEntityInit(withFls);
+    const fields = (init.Fields as Record<string, unknown>[]).map(f => ({ ...f, AllowUpdateAPI: true, AllowsNull: true }));
+    return new EntityInfo({ ...init, Fields: fields });
+}
+
+class Employee extends BaseEntity {
+    public override CheckPermissions(): boolean {
+        return true;
+    }
+}
+
+/** A provider whose database holds one full-width employee row and whose Save returns the stored row. */
+function makeProvider() {
+    let stored = FullWidthEmployeeRow();
+    return {
+        CurrentUser: null as UserInfo | null,
+        async Load(): Promise<Record<string, unknown>> { return { ...stored }; },
+        async Save(entity: BaseEntity): Promise<Record<string, unknown>> {
+            stored = { ...stored, ...(entity.GetAll() as Record<string, unknown>) };
+            return { ...stored };
+        },
+        SetCachedRecordName(): void { /* no-op */ },
+        GetCachedRecordName(): string | undefined { return undefined; },
+    };
+}
+
+class TestResolver extends ResolverBase {
+    public Listen(entity: BaseEntity) {
+        this.ListenForEntityMessages(entity, {} as PubSubEngine, { sessionId: 's' } as UserPayload);
+    }
+    public Payload(entity: BaseEntity, changed?: string[]): Record<string, unknown> {
+        return this.EntityEventPayload(entity, changed);
+    }
+}
+
+async function loadedEmployee(entityInfo: EntityInfo, user: UserInfo): Promise<Employee> {
+    const e = new Employee(entityInfo, makeProvider() as unknown as IEntityDataProvider);
+    e.ContextCurrentUser = user;
+    await e.InnerLoad(CompositeKey.FromID('emp-1'));
+    return e;
+}
+
+describe('ResolverBase CloudEvents: changed fields from a real save', () => {
+    const emitterKey = '_emit';
+    let previousEmitter: unknown;
+
+    beforeEach(() => {
+        cloudEventInits.length = 0;
+        const statics = ResolverBase as unknown as Record<string, unknown>;
+        previousEmitter = statics[emitterKey];
+        statics[emitterKey] = async () => ({});
+    });
+    afterEach(() => {
+        (ResolverBase as unknown as Record<string, unknown>)[emitterKey] = previousEmitter;
+    });
+
+    /** The data of the CloudEvent emitted for the completed save. */
+    async function saveEventData(entity: Employee): Promise<Record<string, unknown>> {
+        new TestResolver().Listen(entity);
+        await expect(entity.Save()).resolves.toBe(true);
+        await vi.waitFor(() => expect(cloudEventInits.some(c => String(c.type).endsWith('.save'))).toBe(true));
+        return cloudEventInits.find(c => String(c.type).endsWith('.save'))!.data as Record<string, unknown>;
+    }
+
+    it('REGRESSION: names the fields the save changed, not an empty list', async () => {
+        const entity = await loadedEmployee(updatableEmployees(true), HRUser());
+        entity.Set('Notes', 'edited');
+        entity.Set('Salary', 1);
+
+        const data = await saveEventData(entity);
+
+        expect(entity.Dirty).toBe(false);
+        expect(data.PrimaryKey).toEqual([{ FieldName: 'ID', Value: 'emp-1' }]);
+        expect([...(data.ChangedFields as string[])].sort()).toEqual(['Notes', 'Salary']);
+        expect(JSON.stringify(data)).not.toContain(String(SECRET_SALARY));
+    });
+
+    it('an entity without field security still emits its row', async () => {
+        const entity = await loadedEmployee(updatableEmployees(false), HRUser());
+        entity.Set('Notes', 'edited');
+
+        const data = await saveEventData(entity);
+
+        expect(data).toMatchObject({ ID: 'emp-1', Notes: 'edited' });
+    });
+
+    it('a payload for a record still in raw mode does not build its field objects', async () => {
+        const entity = new Employee(updatableEmployees(true), makeProvider() as unknown as IEntityDataProvider);
+        entity.ContextCurrentUser = HRUser();
+        await entity.LoadFromData(FullWidthEmployeeRow()); // a load_complete listener sees exactly this object
+        const hydrated = () => (entity as unknown as { _fieldsHydrated: boolean })._fieldsHydrated;
+        expect(hydrated()).toBe(false);
+
+        const data = new TestResolver().Payload(entity);
+
+        expect(data.ChangedFields).toEqual([]);
+        expect(hydrated()).toBe(false);
+    });
+});

package/src/__tests__/resolverBase.fieldSecurityTransport.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Field-level security on ResolverBase's own transports, other than the GraphQL field mapping:
+ *
+ * - **Create input.** A restricted caller's create payload is refused when it names a field the
+ *   caller may not read, or a key that names no field, with the same message for both.
+ * - **Cache-invalidation broadcast.** The event reaches every signed-in session unprojected, so an
+ *   entity under field security never carries its row, whatever the allowlist says.
+ * - **CloudEvents and their debug log.** The sink is external and has no reader identity to
+ *   project for, so an entity under field security emits only its key and the names of changed
+ *   fields, and the same goes for the debug log of the event.
+ *
+ * The entity objects here return FULL-WIDTH rows, standing in for an object saved by the system
+ * user (server-internal saves fire the same events) or otherwise not narrowed at its source.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { published, logDebugCalls, emitted, cloudEventInits } = vi.hoisted(() => ({
+    published: [] as Array<{ topic: string; payload: Record<string, unknown> }>,
+    logDebugCalls: [] as string[],
+    emitted: [] as unknown[],
+    cloudEventInits: [] as Array<Record<string, unknown>>,
+}));
+
+vi.mock('@memberjunction/sqlserver-dataprovider', () => ({ SQLServerDataProvider: class {} }));
+vi.mock('@memberjunction/generic-database-provider', () => ({ UserCache: { Users: [] } }));
+vi.mock('cloudevents', () => ({
+    CloudEvent: class {
+        constructor(init: Record<string, unknown>) {
+            cloudEventInits.push(init);
+            Object.assign(this, init);
+        }
+    },
+    httpTransport: () => () => undefined,
+    emitterFor: () => () => undefined,
+}));
+vi.mock('type-graphql', () => {
+    const noop = () => () => undefined;
+    return {
+        Resolver: noop, Mutation: noop, Query: noop, Subscription: noop, Ctx: noop, Arg: noop, PubSub: noop,
+        Root: noop, ObjectType: noop, InputType: noop, Field: noop, FieldResolver: noop,
+        Int: undefined, Float: undefined, registerEnumType: () => undefined,
+    };
+});
+vi.mock('graphql', () => ({ GraphQLError: class extends Error {} }));
+vi.mock('mssql', () => ({}));
+vi.mock('@memberjunction/api-keys', () => ({ GetAPIKeyEngine: vi.fn() }));
+vi.mock('@memberjunction/encryption', () => ({ EncryptionEngine: { Instance: {} } }));
+vi.mock('@memberjunction/graphql-dataprovider', () => ({ FieldMapper: class { MapFieldName(n: string) { return n; } ReverseMapFieldName(n: string) { return n; } } }));
+vi.mock('../generic/PubSubManager.js', () => ({
+    PubSubManager: {
+        Instance: {
+            Publish: (topic: string, payload: Record<string, unknown>) => { published.push({ topic, payload }); },
+        },
+    },
+}));
+vi.mock('../generic/PushStatusResolver.js', () => ({
+    PUSH_STATUS_UPDATES_TOPIC: 'test-push-topic',
+    PublishStatusUpdate: vi.fn(),
+}));
+vi.mock('../generic/RunViewResolver.js', () => ({ RunViewByIDInput: class {}, RunViewByNameInput: class {}, RunDynamicViewInput: class {} }));
+vi.mock('../generic/DeleteOptionsInput.js', () => ({ DeleteOptionsInput: class {} }));
+vi.mock('../types.js', () => ({ RunViewGenericParams: class {} }));
+vi.mock('@memberjunction/core-entities', () => ({}));
+vi.mock('@memberjunction/core', async () => {
+    const actual = await vi.importActual<typeof import('@memberjunction/core')>('@memberjunction/core');
+    return {
+        ...actual,
+        LogError: vi.fn(),
+        LogStatus: (msg: string) => { logDebugCalls.push(String(msg)); },
+        LogDebug: (msg: string) => { logDebugCalls.push(String(msg)); },
+    };
+});
+
+import { BaseEntity, BaseEntityEvent, EntityInfo, UserInfo } from '@memberjunction/core';
+import { MJEventType, MJGlobal } from '@memberjunction/global';
+import type { PubSubEngine } from 'type-graphql';
+import { ResolverBase } from '../generic/ResolverBase';
+import { ConfigureRecordDataBroadcast } from '../generic/CacheInvalidationResolver.js';
+import type { UserPayload } from '../types.js';
+import { EmployeeEntity, FullWidthEmployeeRow, HRUser, Intern, RefusalFor, SECRET_SALARY } from './fieldSecurityFixtures.js';
+
+/** An entity object that holds a full-width row: system-saved, or not narrowed at its source. */
+function fullWidthEntity(entityInfo: EntityInfo, dirty: string[] = ['Notes']) {
+    const row = FullWidthEmployeeRow();
+    return {
+        EntityInfo: entityInfo,
+        GetAll: () => ({ ...row }),
+        PrimaryKey: { KeyValuePairs: [{ FieldName: 'ID', Value: row.ID }] },
+        PrimaryKeys: [],
+        Fields: entityInfo.Fields.map(f => ({ Name: f.Name, Dirty: dirty.includes(f.Name) })),
+        Get: (name: string) => (row as Record<string, unknown>)[name],
+        GetDirtyFieldNames: () => entityInfo.Fields.filter(f => dirty.includes(f.Name)).map(f => f.Name),
+        SetManyCalls: [] as Array<Record<string, unknown>>,
+        NewRecord(): boolean { return true; },
+        SetMany(values: Record<string, unknown>): void { this.SetManyCalls.push(values); },
+        Save: async () => true,
+    };
+}
+type FullWidthEntity = ReturnType<typeof fullWidthEntity>;
+
+class TestResolver extends ResolverBase {
+    public Create(entity: FullWidthEntity, input: Record<string, unknown>, user: UserInfo) {
+        const provider = { GetEntityObject: async () => entity };
+        return this.CreateRecord('Employees', input, provider as never, { userRecord: user } as UserPayload, {} as PubSubEngine);
+    }
+    public Broadcast(entity: FullWidthEntity) {
+        this.PublishCacheInvalidation(entity as unknown as BaseEntity, 'save', { sessionId: 's' } as UserPayload);
+    }
+    public Emit(entity: FullWidthEntity) {
+        const args = new BaseEntityEvent();
+        args.type = 'save';
+        args.baseEntity = entity as unknown as BaseEntity;
+        return this.EmitCloudEvent({ component: null, event: MJEventType.ComponentEvent, eventCode: BaseEntity.BaseEventCode, args });
+    }
+    public Listen(entity: FullWidthEntity) {
+        this.ListenForEntityMessages(entity as unknown as BaseEntity, {} as PubSubEngine, { sessionId: 's' } as UserPayload);
+    }
+}
+
+describe('ResolverBase.CreateRecord: client input is gated for a restricted caller', () => {
+    it.each([
+        ['a denied field', 'Salary'],
+        ['a key that names no field', 'Bogus'],
+    ])('REGRESSION: refuses %s with the same message, before anything is applied', async (_label, key) => {
+        const entity = fullWidthEntity(EmployeeEntity());
+        await expect(new TestResolver().Create(entity, { ID: 'emp-1', Name: 'Ada', [key]: 1 }, Intern()))
+            .rejects.toThrow(RefusalFor(key));
+        expect(entity.SetManyCalls).toHaveLength(0);
+    });
+
+    it('applies a well-behaved restricted client\'s create', async () => {
+        const entity = fullWidthEntity(EmployeeEntity());
+        // The response mapping needs metadata this unit test does not stand up; reaching it means the gate passed.
+        await new TestResolver().Create(entity, { ID: 'emp-1', Name: 'Ada', RestoreContext___: { SourceChangeID: 'x' } }, Intern()).catch(() => undefined);
+        expect(entity.SetManyCalls).toEqual([{ ID: 'emp-1', Name: 'Ada' }]);
+    });
+
+    it('does not gate a caller who is denied nothing', async () => {
+        const entity = fullWidthEntity(EmployeeEntity());
+        await new TestResolver().Create(entity, { ID: 'emp-1', Salary: 5 }, HRUser()).catch(() => undefined);
+        expect(entity.SetManyCalls).toEqual([{ ID: 'emp-1', Salary: 5 }]);
+    });
+});
+
+describe('ResolverBase.PublishCacheInvalidation: no row data for entities under field security', () => {
+    beforeEach(() => { published.length = 0; });
+    afterEach(() => ConfigureRecordDataBroadcast([]));
+
+    it("REGRESSION: an FLS entity's row never rides along, even under an explicit '*'", () => {
+        ConfigureRecordDataBroadcast(['*']);
+        new TestResolver().Broadcast(fullWidthEntity(EmployeeEntity(true)));
+
+        expect(published).toHaveLength(1);
+        expect(published[0].payload.recordData).toBeUndefined();
+        expect(published[0].payload.entityName).toBe('Employees');
+    });
+
+    it('an allowlisted entity without field security still carries its row', () => {
+        ConfigureRecordDataBroadcast(['*']);
+        new TestResolver().Broadcast(fullWidthEntity(EmployeeEntity(false)));
+
+        expect(JSON.parse(String(published[0].payload.recordData))).toMatchObject({ ID: 'emp-1' });
+    });
+});
+
+describe('ResolverBase CloudEvents: no field values for entities under field security', () => {
+    const emitterKey = '_emit';
+    let previousEmitter: unknown;
+
+    beforeEach(() => {
+        cloudEventInits.length = 0;
+        emitted.length = 0;
+        logDebugCalls.length = 0;
+        const statics = ResolverBase as unknown as Record<string, unknown>;
+        previousEmitter = statics[emitterKey];
+        statics[emitterKey] = async (event: unknown) => { emitted.push(event); return {}; };
+    });
+    afterEach(() => {
+        (ResolverBase as unknown as Record<string, unknown>)[emitterKey] = previousEmitter;
+    });
+
+    it('REGRESSION: emits only the key and the changed-field names', async () => {
+        await new TestResolver().Emit(fullWidthEntity(EmployeeEntity(true), ['Notes', 'Salary']));
+
+        expect(cloudEventInits).toHaveLength(1);
+        expect(cloudEventInits[0].data).toEqual({
+            PrimaryKey: [{ FieldName: 'ID', Value: 'emp-1' }],
+            ChangedFields: ['Salary', 'Notes'],
+        });
+        expect(logDebugCalls.join('\n')).not.toContain(String(SECRET_SALARY));
+    });
+
+    it('an entity without field security still emits its row', async () => {
+        await new TestResolver().Emit(fullWidthEntity(EmployeeEntity(false)));
+        expect(cloudEventInits[0].data).toMatchObject({ ID: 'emp-1', Name: 'Ada' });
+    });
+
+    it('REGRESSION: a Record Changes row emits only its key and changed-field names', async () => {
+        // The audit trail has no field security of its own, but its payload columns hold other
+        // entities' values, so its rows must not ride along to the sink either.
+        const recordChanges = EmployeeEntity(false);
+        recordChanges.Name = 'MJ: Record Changes';
+        await new TestResolver().Emit(fullWidthEntity(recordChanges, ['Notes']));
+        expect(cloudEventInits[0].data).toEqual({
+            PrimaryKey: [{ FieldName: 'ID', Value: 'emp-1' }],
+            ChangedFields: ['Notes'],
+        });
+    });
+
+    it('REGRESSION: the entity-event debug log carries no field values for an FLS entity', async () => {
+        const entity = fullWidthEntity(EmployeeEntity(true));
+        new TestResolver().Listen(entity);
+        const args = new BaseEntityEvent();
+        args.type = 'save';
+        args.baseEntity = entity as unknown as BaseEntity;
+        MJGlobal.Instance.RaiseEvent({ component: null, event: MJEventType.ComponentEvent, eventCode: BaseEntity.BaseEventCode, args });
+        await vi.waitFor(() => expect(logDebugCalls.some(m => m.includes('Received Event'))).toBe(true));
+
+        expect(logDebugCalls.join('\n')).not.toContain(String(SECRET_SALARY));
+        expect(logDebugCalls.join('\n')).toContain('emp-1');
+    });
+});