@verii/server-mockvendor 1.0.0-pre.1752076816

package/src/entities/offers/schemas/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  generateOffersSchema: require('./generate-offers.schema'),
+};

package/src/index.js

@@ -0,0 +1,19 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module.exports = {
+  ...require('./start-app-server'),
+};

package/src/init-server.js

@@ -0,0 +1,34 @@
+const initRequest = require('@verii/request');
+const path = require('path');
+const AutoLoad = require('@fastify/autoload');
+
+const initServer = (server) => {
+  return server
+    .register(AutoLoad, {
+      dir: path.join(__dirname, 'controllers'),
+      ignorePattern: /controller(\.ts|\.js|\.cjs|\.mjs)$/,
+      indexPattern: /.*repo(\.ts|\.js|\.cjs|\.mjs)$/,
+    })
+    .register(AutoLoad, {
+      dir: path.join(__dirname, 'controllers'),
+      autoHooks: true,
+      cascadeHooks: true,
+      indexPattern: /controller(\.ts|\.js|\.cjs|\.mjs)$/,
+    })
+    .after(() =>
+      server
+        .decorate(
+          'baseAgentFetch',
+          initRequest({
+            ...server.config,
+            prefixUrl: server.config.agentUrl,
+          })
+        )
+        .decorateRequest('agentFetch', null)
+        .addHook('preValidation', async (req) => {
+          req.agentFetch = server.baseAgentFetch(req);
+        })
+    );
+};
+
+module.exports = { initServer };

package/src/main.js

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const { startAppServer } = require('./start-app-server');
+
+startAppServer();

package/src/standalone.js

@@ -0,0 +1,8 @@
+/* istanbul ignore file */
+// eslint-disable-next-line import/no-extraneous-dependencies
+const dotenv = require('dotenv');
+
+dotenv.config({ path: '.standalone.env' });
+dotenv.config({ path: '.localdev.env' });
+
+require('./main');

package/src/start-app-server.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2025 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* istanbul ignore next */
+const { flow } = require('lodash/fp');
+const { createServer, listenServer } = require('@verii/server-provider');
+const { initServer } = require('./init-server');
+const config = require('./config/config');
+
+process.on('unhandledRejection', (error) => {
+  console.error(error);
+  process.exit(1);
+});
+
+const startAppServer = () =>
+  flow(createServer, initServer, listenServer)(config);
+
+module.exports = { startAppServer };

package/test/accepted-offers.test.js

@@ -0,0 +1,47 @@
+const { mongoDb } = require('@spencejs/spence-mongo-repos');
+const {
+  ISO_DATETIME_FORMAT,
+  OBJECT_ID_FORMAT,
+} = require('@verii/test-regexes');
+const buildFastify = require('./helpers/mockvendor-build-fastify');
+const initAcceptedOffersFactory = require('./factories/accepted-offers.factory');
+
+describe('Accepted Offer managment', () => {
+  let fastify;
+  let persistAcceptedOffers;
+
+  beforeAll(async () => {
+    fastify = buildFastify();
+    await fastify.ready();
+    ({ persistAcceptedOffers } = initAcceptedOffersFactory(fastify));
+  });
+
+  beforeEach(async () => {
+    await mongoDb().collection('acceptedOffers').deleteMany({});
+  });
+
+  afterAll(async () => {
+    await mongoDb().collection('acceptedOffers').deleteMany({});
+    await fastify.close();
+  });
+
+  it('should retrieve the accepted offers', async () => {
+    const acceptedOffer = await persistAcceptedOffers();
+    const response = await fastify.injectJson({
+      method: 'GET',
+      url: '/api/accepted-offers',
+    });
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toEqual(
+      expect.arrayContaining([
+        {
+          id: expect.stringMatching(OBJECT_ID_FORMAT),
+          _id: expect.stringMatching(OBJECT_ID_FORMAT),
+          createdAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+          updatedAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+          ...acceptedOffer,
+        },
+      ])
+    );
+  });
+});

package/test/api-users.test.js

@@ -0,0 +1,170 @@
+const { mongoDb } = require('@spencejs/spence-mongo-repos');
+const {
+  ISO_DATETIME_FORMAT,
+  OBJECT_ID_FORMAT,
+} = require('@verii/test-regexes');
+const { map, omit, toUpper } = require('lodash/fp');
+const buildFastify = require('./helpers/mockvendor-build-fastify');
+const initUserFactory = require('./factories/users.factory');
+
+describe('Users API Test Suite', () => {
+  let fastify;
+  let newUser;
+  let persistUser;
+
+  beforeAll(async () => {
+    fastify = buildFastify();
+    await fastify.ready();
+    ({ newUser, persistUser } = initUserFactory(fastify));
+  });
+
+  beforeEach(async () => {
+    await mongoDb().collection('users').deleteMany({});
+  });
+
+  afterAll(async () => {
+    await fastify.close();
+  });
+
+  it('should be able to create a user', async () => {
+    const user = await newUser();
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/users',
+      payload: user,
+    });
+
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toEqual({
+      ...user,
+      id: expect.stringMatching(OBJECT_ID_FORMAT),
+      _id: expect.stringMatching(OBJECT_ID_FORMAT),
+      updatedAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+      createdAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+    });
+  });
+  it('should be able to create a user with an uppercase email', async () => {
+    const user = await newUser();
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/users',
+      payload: { ...user, emails: map(toUpper, user.emails) },
+    });
+
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toEqual({
+      ...user,
+      id: expect.stringMatching(OBJECT_ID_FORMAT),
+      _id: expect.stringMatching(OBJECT_ID_FORMAT),
+      updatedAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+      createdAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+    });
+  });
+  it('should be able to create a user with a token', async () => {
+    const user = await newUser({ token: 'foo' });
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/users',
+      payload: { ...user, emails: map(toUpper, user.emails) },
+    });
+
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toEqual({
+      ...user,
+      token: 'foo',
+      id: expect.stringMatching(OBJECT_ID_FORMAT),
+      _id: expect.stringMatching(OBJECT_ID_FORMAT),
+      updatedAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+      createdAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+    });
+  });
+  it('should be able to get a user', async () => {
+    const user = await persistUser({ token: 'foo' });
+    const response = await fastify.injectJson({
+      method: 'GET',
+      url: `/api/users/${user._id}`,
+    });
+
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toEqual({
+      ...user,
+      token: 'foo',
+      id: expect.stringMatching(OBJECT_ID_FORMAT),
+      _id: expect.stringMatching(OBJECT_ID_FORMAT),
+      updatedAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+      createdAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+    });
+  });
+  it('should be able to get all users', async () => {
+    const [user1, user2] = await Promise.all([persistUser(), persistUser()]);
+    const response = await fastify.injectJson({
+      method: 'GET',
+      url: '/api/users',
+    });
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toEqual(
+      expect.arrayContaining([
+        {
+          ...user1,
+          id: expect.stringMatching(OBJECT_ID_FORMAT),
+          _id: expect.stringMatching(OBJECT_ID_FORMAT),
+          updatedAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+          createdAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+        },
+        {
+          ...user2,
+          id: expect.stringMatching(OBJECT_ID_FORMAT),
+          _id: expect.stringMatching(OBJECT_ID_FORMAT),
+          updatedAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+          createdAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+        },
+      ])
+    );
+  });
+  it('should be able to update a user', async () => {
+    const [user1] = await Promise.all([persistUser(), persistUser()]);
+    const response = await fastify.injectJson({
+      method: 'PUT',
+      url: `/api/users/${user1._id}`,
+      payload: {
+        ...omit(['id', '_id', 'createdAt', 'updatedAt'], user1),
+        firstName: 'Mary',
+        token: 'foo',
+      },
+    });
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toEqual({
+      ...user1,
+      id: expect.stringMatching(OBJECT_ID_FORMAT),
+      updatedAt: expect.stringMatching(ISO_DATETIME_FORMAT),
+      token: 'foo',
+      firstName: 'Mary',
+    });
+  });
+  it('should be able to delete a user', async () => {
+    const [, user2] = await Promise.all([persistUser(), persistUser()]);
+    const getResponsePre = await fastify.injectJson({
+      method: 'GET',
+      url: '/api/users',
+    });
+    expect(getResponsePre.json).toEqual(
+      expect.arrayContaining([
+        { ...user2, id: expect.stringMatching(OBJECT_ID_FORMAT) },
+      ])
+    );
+    const response = await fastify.injectJson({
+      method: 'DELETE',
+      url: `/api/users/${user2._id}`,
+    });
+    expect(response.statusCode).toEqual(200);
+    const getResponsePost = await fastify.injectJson({
+      method: 'GET',
+      url: '/api/users',
+    });
+    expect(getResponsePost.json).not.toEqual(
+      expect.arrayContaining([
+        { ...user2, id: expect.stringMatching(OBJECT_ID_FORMAT) },
+      ])
+    );
+  });
+});

package/test/create_did_key-controller.test.js

@@ -0,0 +1,94 @@
+const buildFastify = require('./helpers/mockvendor-build-fastify');
+
+describe('create_did_key controller test suite', () => {
+  let fastify;
+
+  beforeAll(async () => {
+    fastify = await buildFastify({});
+    await fastify.ready();
+  });
+
+  afterAll(async () => {
+    await fastify.close();
+  });
+
+  it('should return 400 if the request body is invalid', async () => {
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/create_did_key',
+      payload: {},
+    });
+    expect(response.statusCode).toEqual(400);
+    expect(response.json).toStrictEqual({
+      code: 'FST_ERR_VALIDATION',
+      message: "body must have required property 'crv'",
+      statusCode: 400,
+      error: 'Bad Request',
+    });
+  });
+
+  it('should return 400 if the crv is invalid', async () => {
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/create_did_key',
+      payload: {
+        crv: 'abc',
+      },
+    });
+    expect(response.statusCode).toEqual(400);
+    expect(response.json).toStrictEqual({
+      code: 'FST_ERR_VALIDATION',
+      message: 'body/crv must be equal to one of the allowed values',
+      statusCode: 400,
+      error: 'Bad Request',
+    });
+  });
+
+  it('should create a new P-256 did key', async () => {
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/create_did_key',
+      payload: {
+        crv: 'P-256',
+        didMethod: 'did:jwk',
+        didKeyId: 'abc1',
+      },
+    });
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toStrictEqual({
+      keyId: expect.any(String),
+      kid: expect.any(String),
+      did: expect.any(String),
+      publicJwk: {
+        crv: 'P-256',
+        kty: 'EC',
+        x: expect.any(String),
+        y: expect.any(String),
+      },
+    });
+  });
+
+  it('should create a new secp256k1 did key', async () => {
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/create_did_key',
+      payload: {
+        crv: 'secp256k1',
+        didMethod: 'did:jwk',
+        didKeyId: 'abc1',
+      },
+    });
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toStrictEqual({
+      keyId: expect.any(String),
+      kid: expect.any(String),
+      did: expect.any(String),
+      publicJwk: {
+        crv: 'secp256k1',
+        kty: 'EC',
+        x: expect.any(String),
+        y: expect.any(String),
+      },
+    });
+  });
+});

package/test/create_jwk-controller.test.js

@@ -0,0 +1,86 @@
+const buildFastify = require('./helpers/mockvendor-build-fastify');
+
+describe('create_jwk controller test suite', () => {
+  let fastify;
+
+  beforeAll(async () => {
+    fastify = await buildFastify({});
+    await fastify.ready();
+  });
+
+  afterAll(async () => {
+    await fastify.close();
+  });
+
+  it('should return 400 if the request body is invalid', async () => {
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/create_jwk',
+      payload: {},
+    });
+    expect(response.statusCode).toEqual(400);
+    expect(response.json).toStrictEqual({
+      code: 'FST_ERR_VALIDATION',
+      message: "body must have required property 'crv'",
+      statusCode: 400,
+      error: 'Bad Request',
+    });
+  });
+
+  it('should return 400 if the crv is invalid', async () => {
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/create_jwk',
+      payload: {
+        crv: 'abc',
+      },
+    });
+    expect(response.statusCode).toEqual(400);
+    expect(response.json).toStrictEqual({
+      code: 'FST_ERR_VALIDATION',
+      message: 'body/crv must be equal to one of the allowed values',
+      statusCode: 400,
+      error: 'Bad Request',
+    });
+  });
+
+  it('should create a new jwk', async () => {
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/create_jwk',
+      payload: {
+        crv: 'P-256',
+      },
+    });
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toStrictEqual({
+      keyId: expect.any(String),
+      jwk: {
+        crv: 'P-256',
+        kty: 'EC',
+        x: expect.any(String),
+        y: expect.any(String),
+      },
+    });
+  });
+
+  it('should create a new jwk', async () => {
+    const response = await fastify.injectJson({
+      method: 'POST',
+      url: '/api/create_jwk',
+      payload: {
+        crv: 'secp256k1',
+      },
+    });
+    expect(response.statusCode).toEqual(200);
+    expect(response.json).toStrictEqual({
+      keyId: expect.any(String),
+      jwk: {
+        crv: 'secp256k1',
+        kty: 'EC',
+        x: expect.any(String),
+        y: expect.any(String),
+      },
+    });
+  });
+});