https://github.com/loredanacirstea
https://twitter.com/lorecirstea
md`# Pipeline Utils Dev`
// solidityBuilder = (await require('http://127.0.0.1:5000/pipesource/dist/pipesource.min.js')).solidityBuilder;
solidityBuilder = (await require('@pipeos/pipesource@0.0.3/dist/pipesource.min.js')).solidityBuilder;
pipedb = 'https://pipeline.pipeos.one/server';
function getContext(graph, fcontext) {
console.log('getContext', graph, fcontext);
return resolveDb(getFuncsFromGraph(graph), fcontext);
}
async function setPGraph(graph) {
const pipeapi = `${pipedb}/graph`;
const graphObj = Object.assign({}, {name: 'Graph Name', markdown: '# Graph Title'}, graph);
let response;
try {
response = await window.fetch(pipeapi, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(graphObj)
});
} catch (e) {
console.error('setPGraph', e);
return null;
}
return await response.json();
}
async function getPGraph(id) {
const pipeapi = `${pipedb}/graph/${id}`;
let graph;
try {
graph = await window.fetch(pipeapi);
} catch (e) {
console.error('getPGraph', e);
return null;
}
return graph.json();
}
async function getPFunc(funcid) {
const pipeapi = `${pipedb}/pfunction/${funcid}`;
return window.fetch(pipeapi);
}
async function getPClass(pclassid) {
const pipeapi = `${pipedb}/pclass/${pclassid}`;
return window.fetch(pipeapi);
}
async function getPClassI(pclassid) {
const pipeapi = `${pipedb}/pclassi?filter={"where":{"pclassid":"${pclassid}"}}`;
return window.fetch(pipeapi);
}
function getJSFunctions() {
const api = `${pipedb}/pfunction?filter={"where":{"pclassid":"5dbaa731f18ff7488e9b108b","pfunction.sources.javascript": {"neq": null}}}`;
return window.fetch(api)
.then(response => response.json())
.then(pfuncs => pfuncs.map(data => prepPFunction(data)));
}
function getFuncsFromGraph(gf) {
let out = []
for (let node in gf.n) {
if (gf.n[node].i < 3000) {
out.push(gf.n[node].id)
}
}
return out
}
async function resolveDb(arrFunc, fcontext) {
let arr = arrFunc.filter(x=>!(x in fcontext))
let merged = {};
let pclasses = {};
const pfuncs = await Promise.all(arr.map(getPFunc));
for (let pfunc of pfuncs) {
let data = await pfunc.json();
if (!pclasses[data.pclassid]) {
const pclass = await getPClass(data.pclassid);
const pclassdata = await pclass.json();
const pclassi = await getPClassI(data.pclassid);
const pclassidata = (await pclassi.json())[0];
pclassdata.deployment = (pclassidata && pclassidata.pclassi && pclassidata.pclassi.address) ? pclassidata.pclassi.address : '';
pclasses[data.pclassid] = pclassdata;
}
data.pclass = pclasses[data.pclassid];
data = prepPFunction(data);
merged[data._id] = data;
if (data.pfunction.graph && data.pfunction.graph != {}) {
resolveDb(getFuncsFromGraph(data.pfunction.graph), fcontext)
}
}
return merged;
}
function prepPFunction(data) {
const allowedGapiKeys = [
'type', 'name', 'inputs', 'outputs',
'stateMutability', 'payable', 'constant',
'anonymous',
];
let pclass;
if (!data.pclass) {
pclass = {
_id: '0x0',
name: 'unknown',
type: 'unknown',
deployment: 'unknown',
}
} else {
pclass = {
_id: data.pclass._id,
name: data.pclass.name,
type: data.pclass.type,
deployment: data.pclass.deployment,
}
}
const gapi = JSON.parse(JSON.stringify(data.pfunction.gapi));
Object.keys(gapi).forEach(key => {
if (!allowedGapiKeys.includes(key)) {
delete gapi[key];
}
});
// backwards compatibility
if (!gapi.stateMutability) {
gapi.stateMutability = gapi.payable ? 'payable' : (gapi.constant ? 'view' : 'nonpayable');
}
// if (gapi.anonymous) {
// delete gapi.anonymous;
// }
let pfunc = {
_id: data._id,
pclassid: data.pclassid,
pfunction: {
signature: data.pfunction.signature,
gapi,
graph: data.pfunction.graph || {},
sources: data.pfunction.sources || {},
},
timestamp: data.timestamp,
pclass,
}
if (pfunc.pclass.type === 'sol') {
pfunc = solidityBuilder.enrichAbi(pfunc);
}
return pfunc;
}
async function searchPClasses(query = {}, filter = {}) {
const ufilter = Object.assign({}, {limit: 15, skip: 0}, filter);
const pipeapiCount = `${pipedb}/pclass/count?where=${JSON.stringify(query)}`;
const pipeapiPF = `${pipedb}/pclass/pfunctions?filter=${JSON.stringify(Object.assign({}, ufilter, {where: query}))}`;
const count = (await window.fetch(pipeapiCount).then(resp => resp.json()).catch(console.log)) || 0;
const response = (await window.fetch(pipeapiPF).then(resp => resp.json()).catch(console.log)) || [];
console.log('searchPClasses', response)
const pclassMap = searchDbPrep(response.pclasses, response.pfunctions, response.pclassii);
return {count: count.count, pclassMap}
}
async function searchPFunctions(query = {}, filter = {}) {
const ufilter = Object.assign({}, {limit: 15, skip: 0}, filter);
const pipeapiCount = `${pipedb}/pfunction/count?where=${JSON.stringify(query)}`;
const pipeapiPF = `${pipedb}/pfunction?filter=${JSON.stringify(Object.assign({}, ufilter, {where: query}))}`;
const count = (await window.fetch(pipeapiCount).then(resp => resp.json()).catch(console.log)) || 0;
const pfunctions = (await window.fetch(pipeapiPF).then(resp => resp.json()).catch(console.log)) || [];
const pclassids = new Set(pfunctions.map(pfunc => pfunc.pclassid));
const pipeapiPC = `${pipedb}/pclass?filter={"where":{"_id":{"inq":${JSON.stringify([...pclassids])}}}}`;
const pclasses = (await window.fetch(pipeapiPC).then(resp => resp.json()).catch(console.log)) || [];
const pipeapiI = `${pipedb}/pclassi?filter={"where":{"pclassid":{"inq":${JSON.stringify([...pclassids])}}}}`;
const pclassii = (await window.fetch(pipeapiI).then(resp => resp.json()).catch(console.log)) || [];
const pclassMap = searchDbPrep(pclasses, pfunctions, pclassii);
return {count: count.count, pclassMap}
}
function searchDbPrep(pclasses, pfunctions, pclassii) {
const pclassMap = {};
pclasses.forEach((pc, i) => {
if (pc.type !== 'sol') return;
pclassMap[pc._id] = pc;
pclassMap[pc._id].pfunctions = [];
})
pfunctions.forEach((pf, i) => {
if (!pclassMap[pf.pclassid]) return;
pf.pclass = pclassMap[pf.pclassid];
pclassMap[pf.pclassid].pfunctions.push(pf);
})
pclassii.forEach(pi => {
if (!pclassMap[pi.pclassid]) return;
const pfuncs = [];
pclassMap[pi.pclassid].pfunctions.forEach(pf => {
pf.pclass.deployment = (pi && pi.pclassi && pi.pclassi.address) ? pi.pclassi.address : '';
try {
pfuncs.push(prepPFunction(pf));
} catch (e) {
console.log(e);
}
})
pclassMap[pi.pclassid].pfunctions = pfuncs;
})
return pclassMap;
}
async function searchDb(collections=[], query = {}, filter = {}) {
const groups = {}
const ufilter = Object.assign({}, {limit: 15, skip: 0}, filter);
for (let coll of collections) {
let result = [];
let count = 0;
const where = query;
// const whereName = {name: {like: value, options: 'i'}};
// const where = {and: [whereName, query]}
const pipeapiCount = `${pipedb}/${coll}/count?where=${JSON.stringify(where)}`;
const pipeapi = `${pipedb}/${coll}?filter=${JSON.stringify(Object.assign({}, ufilter, {where}))}`;
console.log('where', where);
console.log('pipeapiCount', pipeapiCount);
console.log('pipeapi', pipeapi);
try {
const resp = await window.fetch(pipeapiCount);
count = (await resp.json()).count;
} catch (e) {
console.error(e);
}
try {
const resp = await window.fetch(pipeapi);
result = await resp.json();
} catch (e) {
console.error(e);
}
groups[coll] = {count, items: result};
}
return groups;
// http://pipeline.pipeos.one/server/pclass/pfunctions?filter={%22offset%22:0,%22limit%22:20,%22skip%22:40,%22where%22:{}}
// http://pipeline.pipeos.one/server/pclass/count?where={%22name%22:{%22like%22:%22market%22,%22options%22:%22i%22}}
// http://pipeline.pipeos.one/server/project?filter={%22where%22:{%22name%22:{%22like%22:%22market%22,%22options%22:%22i%22}}}
// http://pipeline.pipeos.one/server/pclass/pfunctions?filter={%22offset%22:0,%22limit%22:20,%22skip%22:0,%22where%22:{%22name%22:{%22like%22:%22market%22,%22options%22:%22i%22}}}
}
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
