loopback.js `POST /foo` isn't offered when using relations - loopbackjs

I need a series of endpoints like:
POST /company
POST /company/{id}/customers
POST /company/{id}/customers/{fk}
GET /company/{id}/customers/{fk}
I get #2 and #3 ok, but not number 1 - so, when I try GET /company/{id}/customers/{fk} - it naturally tells me that company id xxx doesn't exist. Yet, the endpoints don't exist.
Below is my configuration if anyone can explain what I am missing
{
"_meta": {
"sources": [
"loopback/common/models",
"loopback/server/models",
"../common/models",
"./models"
],
"mixins": [
"loopback/common/mixins",
"loopback/server/mixins",
"../common/mixins",
"./mixins"
]
},
"customer": {
"dataSource": "memory",
"public": false
},
"company": {
"dataSource": "memory",
"public": true
},
"payment": {
"dataSource": "memory",
"public": false
},
"invoice": {
"dataSource": "memory",
"public": false
},
"integration": {
"dataSource": "memory",
"public": true
}
}
Company model:
{
"name": "company",
"plural": "companies",
"base": "Model",
"idInjection": true,
"options": {
"validateUpsert": true
},
"properties": {
"id": {
"type": "string",
"required": true
}
},
"validations": [],
"relations": {
"customers": {
"type": "hasMany",
"model": "customer",
"foreignKey": "id"
},
"payments": {
"type": "hasMany",
"model": "payment",
"foreignKey": "id"
},
"invoices": {
"type": "hasMany",
"model": "invoice",
"foreignKey": "id"
},
"integration": {
"type": "hasOne",
"model": "integration",
"foreignKey": "companyId",
"primaryKey": "id"
}
},
"acls": [],
"methods": {}
}
Customers (properties removed for brevity sake):
{
"name": "customer",
"plural": "customers",
"base": "Model",
"idInjection": true,
"options": {
"validateUpsert": true
},
"validations": [],
"relations": {
"company": {
"type": "belongsTo",
"model": "company",
"foreignKey": "id",
"primaryKey": "id"
}
},
"acls": [],
"methods": {}
}

Related

correct way to define Loopback.io belongsTo relationship

I have a simple has_many-belongst_to relationship between 2 Loopback models:
{
"name": "ApiUser",
"base": "PersistedModel",
"idInjection": true,
"options": {
"postgresql": {
"table": "users"
},
"validateUpsert": true
},
"properties": {
"id": {
"type": "string",
"id": true,
"required": true,
"defaultFn": "uuid",
"postgresql": {
"dataType": "uuid"
}
},
"email": {
...
and
{
"name": "ShopifyAccount",
"base": "PersistedModel",
"idInjection": true,
"options": {
"validateUpsert": true
},
"properties": {
"api_key": {
"type": "string",
"required": true
},
"password": {
"type": "string",
"required": true
}
},
"validations": [],
"relations": {
"orders": {
"type": "hasMany",
"model": "ShopifyOrder",
"foreignKey": ""
},
"user": {
"type": "belongsTo",
"model": "ApiUser",
"foreignKey": "userid"
}
},
"acls": [],
"methods": {}
}
When I run automigration, the shopifyaccount table is created, but it looks weird:
Column | Type | Modifiers
-------------------+---------+-------------------------------------------------------------
api_key | text | not null
password | text | not null
id | integer | not null default nextval('shopifyaccount_id_seq'::regclass)
userid | uuid |
apiuserid | uuid |
Indexes:
"shopifyaccount_pkey" PRIMARY KEY, btree (id)
Why did it create 2 columns named like this? Even if I try to specify that foreignkey is "userid", it will still create the apiuserid column. The insert will never update the apiuserid column but it will update the userid column. And then at join time, it will try to join on apiuserid. What am I doing wrong?
So... it seems that the "foreignkey" needs to be specified in both places, in ApiUser and in ShopifyAccount:
{
"name": "ApiUser",
"base": "PersistedModel",
"idInjection": true,
"options": {
"postgresql": {
"table": "users"
},
"validateUpsert": true
},
"properties": {
"id": {
"type": "string",
"id": true,
"required": true,
"defaultFn": "uuid",
"postgresql": {
"dataType": "uuid"
}
},
"email": {
"type": "string",
...
"relations": {
"shopifyAccounts": {
"type": "hasOne",
"model": "ShopifyAccount",
"foreignKey": "userid"
}
},
"acls": [],
"methods": {}
}

Loopback hasManyThrough relation for user

I have such models:
Team
{
"name": "Team",
"plural": "teams",
"base": "PersistedModel",
"idInjection": true,
"options": {
"validateUpsert": true
},
"mixins": {
"ModelRest": {}
},
"hidden": [
"deleted"
],
"filtered": [
"userId",
"archived"
],
"properties": {
"name": {
"type": "string",
"required": true
},
"createdAt": {
"type": "date"
},
"deleted": {
"type": "boolean"
}
},
"validations": [],
"relations": {
"projects": {
"type": "hasMany",
"model": "Project"
},
"user": {
"type": "belongsTo",
"model": "user"
},
"users": {
"type": "hasMany",
"model": "User",
"foreignKey": "",
"through": "TeamMember"
}
},
"acls": [],
"methods": {}
}
TeamMember
{
"name": "TeamMember",
"plural": "team-members",
"base": "Model",
"idInjection": false,
"options": {
"validateUpsert": true
},
"properties": {},
"validations": [],
"relations": {
"user": {
"type": "belongsTo",
"model": "user"
},
"team": {
"type": "belongsTo",
"model": "Team"
}
},
"acls": [],
"methods": {}
}
user
{
"name": "user",
"plural": "users",
"base": "User",
"idInjection": true,
"mixins": {
"ModelRest": {}
},
"hidden": [
"realm",
"emailVerified",
"lastIP",
"deleted",
"utmSource",
"utmMedium",
"utmCampaign"
],
"readOnly": [
"statusId",
"lastListId",
"teamId",
"subscriptionStart",
"subscriptionExpiration",
"apiKey"
],
"properties": {
"name": {
"type": "string",
"required": true,
"mysql": {
"columnName": "username"
}
},
"password": {
"type": "string",
"required": true,
"min": 5
},
"email": {
"type": "string",
"required": true
},
"createdAt": {
"type": "date"
},
"updatedAt": {
"type": "date"
},
"subscriptionStart": {
"type": "date"
},
"subscriptionExpiration": {
"type": "date"
},
"teamId": {
"type": "number"
},
"sharePlan": {
"type": "boolean"
},
"shareLeads": {
"type": "boolean"
},
"timezone": {
"type": "string"
},
"utmSource": {
"type": "string"
},
"utmMedium": {
"type": "string"
},
"utmCampaign": {
"type": "string"
},
"lastIP": {
"type": "string"
},
"deleted": {
"type": "boolean"
}
},
"validations": [],
"relations": {
"team": {
"type": "belongsTo",
"model": "Team"
},
"plan": {
"type": "belongsTo",
"model": "Plan"
},
"billingCycle": {
"type": "belongsTo",
"model": "BillingCycle"
},
"card": {
"type": "belongsTo",
"model": "Card"
},
"lastList": {
"type": "belongsTo",
"model": "List"
},
"status": {
"type": "belongsTo",
"model": "Status"
},
"accessTokens": {
"type": "hasMany",
"model": "AccessToken"
}
},
"acls": [],
"methods": {}
}
I've created relation in Team model:
"users": {
"type": "hasMany",
"model": "User",
"foreignKey": "",
"through": "TeamMember"
}
But users relation in Team doesn't work at all. In API explorer I see
GET /teams/{id}/user
there is no
GET /teams/{id}/users
Why does this happen?
I've even created this relation with Loopback relation generator. Same result. Can't figure out where is the error. Loopback doest see this relation.
Thanks for any help.
It's all, because in model-config.json I have
"TeamMember": {
"dataSource": null,
"public": true
},
instead of:
"TeamMember": {
"dataSource": "db",
"public": true
},

Remove pk in the loopback swagger

In loopback, how could I remove the PK from the swagger json displayed.
This is the json displayed in my swagger:
{
"user_id": "string",
"order_type": "string",
"date": "2016-04-28",
"payload": {
"id": 0
},
"id": 0
}
image detail- Swagger
how could I remove the "id": 0 ?
This is my order.json :
{
"name": "Order",
"plural": "Orders",
"base": "Model",
"idInjection": true,
"options": {
"validateUpsert": true
},
"properties": {
"user_id": {
"type": "string",
"required": true
},
"order_type": {
"type": "string",
"required": true
},
"date": {
"type": "date",
"required": true
},
"payload": {
"type": "Payload",
"required": true
}
},
"validations": [],
"relations": {},
"acls": [],
"methods": {}
}
This is my order.js:
module.exports = (Order) => {
Order.create = function(body, cb) {
//
}
Order.remoteMethod('create', {
'http': {'path': '/'},
'accepts': [
{'arg': 'body', 'type': 'Order', 'required': true, 'http': { 'source': 'body' } }
]
});
};
Hidden property did the trick
{
"name": "Order",
"plural": "Orders",
"base": "Model",
"idInjection": false,
"options": {
"validateUpsert": true
},
"properties": {
...
},
"validations": [],
"relations": {},
"acls": [],
"methods": {},
"hidden": ["id"]
}

Has many through relation, count always returns 0

I have a table of companies, a table of addresses and a companiesaddresses table to normalize the many to many relationship. Loopback is working just fine to add a company, add an address to a company and I can even query using the API explorer an address associated with a company using the (POST /Companies/{id}/addresses/{fk}) method.
However, when I try to get all the addresses associated with a company (GET /Companies/{id}/addresses) I get back an empty array. Also when I perform a count on how many addresses a particular company has ( GET /Companies/{id}/addresses/count) I always get 0.
I'm sure I'm missing something really tiny. My datasource is postgresql.
/* ----- common/models/companies.json ----- */
{
"name": "Companies",
"base": "User",
"strict": true,
"idInjection": false,
"options": {
"validateUpsert": true
},
"properties": {
"companyName": {
"type": "string",
"required": true
},
"firstName": {
"type": "string",
"required": true
},
"lastName": {
"type": "string",
"required": true
},
"cellNumber": {
"type": "string"
}
},
"validations": [],
"relations": {
"addresses": {
"type": "hasMany",
"model": "Addresses",
"foreignKey": "addressesid",
"through": "CompaniesAddresses"
}
},
"acls": [
{
"accessType": "*",
"principalType": "ROLE",
"principalId": "$everyone",
"permission": "DENY"
},
{
"accessType": "EXECUTE",
"principalType": "ROLE",
"principalId": "$everyone",
"permission": "ALLOW",
"property": "create"
},
{
"accessType": "READ",
"principalType": "ROLE",
"principalId": "$owner",
"permission": "ALLOW"
},
{
"accessType": "WRITE",
"principalType": "ROLE",
"principalId": "$owner",
"permission": "ALLOW"
}
],
"methods": {}
/* ---- common/models/addresses.json ---- */
{
"name": "Addresses",
"base": "PersistedModel",
"strict": true,
"idInjection": false,
"options": {
"validateUpsert": true
},
"properties": {
"streetaddress2": {
"type": "string"
},
"phonenumber2": {
"type": "string"
},
"phonenumber1": {
"type": "string",
"required": true
},
"zippostalcode": {
"type": "string",
"required": true
},
"stateprov": {
"type": "string",
"required": true
},
"streetaddress1": {
"type": "string",
"required": true
}
},
"validations": [],
"relations": {
"companies": {
"type": "hasMany",
"model": "Companies",
"foreignKey": "companiesid",
"through": "CompaniesAddresses"
}
},
"acls": [
{
"accessType": "*",
"principalType": "ROLE",
"principalId": "$everyone",
"permission": "ALLOW"
}
],
"methods": {}
/* ---- companiesaddresses.json ---- */
{
"name": "CompaniesAddresses",
"base": "PersistedModel",
"strict": true,
"idInjection": false,
"options": {
"validateUpsert": true
},
"properties": {
"companiesid": {
"type": "number",
"id": true,
"required": true
},
"addressesid": {
"type": "number",
"id": true,
"required": true
}
},
"validations": [],
"relations": {
"addresses": {
"type": "belongsTo",
"model": "Addresses",
"foreignKey": "addressesid"
},
"companies": {
"type": "belongsTo",
"model": "Companies",
"foreignKey": "companiesid"
}
},
"acls": [
{
"accessType": "*",
"principalType": "ROLE",
"principalId": "$everyone",
"permission": "ALLOW"
}
],
"methods": {}
}
/* ---- server/boot/model-config.json ---- */
{
"_meta": {
"sources": [
"loopback/common/models",
"loopback/server/models",
"../common/models",
"./models"
],
"mixins": [
"loopback/common/mixins",
"loopback/server/mixins",
"../common/mixins",
"./mixins"
]
},
"User": {
"dataSource": "db"
},
"AccessToken": {
"dataSource": "db",
"public": false
},
"ACL": {
"dataSource": "db",
"public": false
},
"RoleMapping": {
"dataSource": "db",
"public": false
},
"Role": {
"dataSource": "db",
"public": false
},
"Companies": {
"dataSource": "pg",
"public": true,
"$promise": {},
"$resolved": true
},
"Addresses": {
"dataSource": "pg",
"public": true,
"$promise": {},
"$resolved": true
},
"CompaniesAddresses": {
"dataSource": "pg",
"public": true,
"$promise": {},
"$resolved": true
}
}
The foreign keys in companies and addresses are as follows:
**common/models/companies.json**
"relations": {
"addresses": {
"type": "hasMany",
"model": "Addresses",
"foreignKey": "addressesid", <---- this should be companiesid
"through": "CompaniesAddresses"
}
}
On the flip side (addresses) do the same modification, all will work.

Dual belongsTo relations with loopback

I have a couple relations I want to model,
A Message belongs to 2 Profile's (a sender and a recipient)
An Enrollment consists of a Profile and a Curriculum.
I tried to do #1 using 2 hasOne but ended up with Profile.messageId.
{
"name": "Message",
"base": "PersistedModel",
"idInjection": true,
"options": {
"validateUpsert": true
},
"properties": {
"id": {
"type": "number",
"id": true,
"required": true
},
"text": {
"type": "string",
"required": true
},
"created": {
"type": "date",
"required": true
},
"seen": {
"type": "boolean",
"required": true
}
},
"validations": [],
"relations": {
"sender": {
"type": "hasOne",
"model": "Profile",
"foreignKey": ""
},
"recipient": {
"type": "hasOne",
"model": "Profile",
"foreignKey": ""
}
},
"acls": [],
"methods": []
}
Same problem w/ #2...
{
"name": "Enrollment",
"base": "PersistedModel",
"idInjection": true,
"options": {
"validateUpsert": true
},
"properties": {
"id": {
"type": "number",
"id": true,
"required": true
},
"created": {
"type": "date",
"required": true
},
"currentPage": {
"type": "string",
"comments": "What page are they on in this curriculum?"
}
},
"validations": [],
"relations": {
"curriculums": {
"type": "hasOne",
"model": "Curriculum",
"foreignKey": ""
},
"profiles": {
"type": "hasOne",
"model": "Profile",
"foreignKey": ""
}
},
"acls": [],
"methods": []
}