'image', (select store_image.url from store_image where store_image.store = store.id limit 1)--order by rank someday

									'image', (select store_image.url from store_image where store_image.store = store.id limit 1),--order by rank someday
									'online', URL is not null and address is null and address2 is null and city is null and postal_code is null and coordinate is null and timezone is null

								'url', store.URL || path

								'url', store.URL || path,
								'menu_item', menu_item.id

							//need to check if menu item actually belongs to the store
							//and check if store belongs to the user

				let wow = await pool.query('select store.url || path as fuck from menu_item inner join store on menu_item.store = store.id where variant = $1 and store = $2', [parameters.variant, parameters.store]);
				if(wow.rows.length && wow.rows[0].fuck !== null) {
					ws.send(JSON.stringify({
						response_ID: request_ID,
						data: wow.rows[0].fuck
					}));
					break;
				}

				//todo: timeout / decrementing stock(probably a cron job) ) idea: can only add to cart if stock minus sum of all line items menu items from carts that are less than or equal to ready. once beyond ready, actually decrement stock
				//or settimeout to delete. if server crashes, on next initialization check all cart age?

					//https://medium.com/@betakuang/why-postgresqls-on-conflict-cannot-find-my-partial-unique-index-552327b85e1
					let cart = (await pool.query(`insert into cart (user_account, store) values ($1, $2) on conflict (user_account, store) where status is null or status = 'placed' or status = 'ready' do nothing returning id`, [ws.user_ID, parameters.store])).rows;
					//unhandled: currently pending order should not be allowed to create new cart.! if we allowed creating new cart while pending order, when an order gets cancelled, status is set to null, and cart will reappear. now there will be 2 carts for same store
					//can we solve this with where status is null | placed | ready do nothing ? will it still use the unique partial index? I think so - just update the partial index

					let cart = (await pool.query(`insert into cart (user_account, store) values ($1, (select store from menu_item where id = $2)) on conflict (user_account, store) where status is null or status = 'placed' or status = 'ready' do nothing returning id`, [ws.user_ID, parameters.menu_item])).rows;

						let kart = (await pool.query(`select id from cart where user_account = $1 and store = $2 and status is null`, [ws.user_ID, parameters.store])).rows;

						let kart = (await pool.query(`select id from cart where user_account = $1 and store = (select store from menu_item where id = $2) and status is null`, [ws.user_ID, parameters.menu_item])).rows;

							console.log('wtf??');

							ws.send(JSON.stringify({
								response_ID: request_ID,
								data: 'failed to add to cart. you already have an order in progress with this store.'
							}));
							break;

							console.log('kys');

							ws.send(JSON.stringify({
								response_ID: request_ID,
								data: 'kys: ' + kart.length
							}));
							break;

						console.log("how the fuck can this happen??");

						ws.send(JSON.stringify({
							response_ID: request_ID,
							data: 'how the fuck can this happen??: ' + cart.length
						}));
						break;

					console.log(cart);

					//check qty here? and current limit of cart

							select $1, id, 1 from menu_item where variant = $2 and store = $3

							values ($1, $2, 1)

							[cart, parameters.variant, parameters.store]

							[cart, parameters.menu_item]

					}));//do we need a try catch?

					}));

					//keep cart in ws only?? idk// or keep client side only? bad for analytics though

					//todo: and not logged in(cart id as input and output. localstorage array of ids on clientside
					//maybe ws onclose, delete the cart? better hope their connection is good

				//is this good enough check line_item belongs to user?
				await pool.query('delete from line_item using cart where line_item.cart = cart.id and cart.user_account = $1 and line_item.id = $2', [ws.user_ID, parameters.line_item]);
				ws.send(JSON.stringify({
					response_ID: request_ID
				}));

								sum(variant.gram_equivalency) as idk,

									'id', line_item.id,

									'concentration_unit', product.concentration_unit,
									'measurement_unit', product.measurement_unit,