example of adding a propery on the fly on auto created endpoint

[f1-outsourcing]

Could your add to your example how one can add a property before executing an insert/update query? Eg add _created timestamp property to the type Comment so this is stored in the database.

type Comment {
  id: ID
  text: String
}

[ardatan]

like I asked the other issues/discussions you've created;
#1710 (reply in thread)

[f1-outsourcing]

I can send you on mail what I have running, I am testing a with keycloak to add auth. I have created a container that by default connects to the demo database of neo4j. Anyone can access it. I am still using it to test (except for write actions, those are not allowed there)

 10     NEO4J_URI="bolt://demo.neo4jlabs.com:7687" \
 11     NEO4J_DB="movies" \
 12     NEO4J_USERNAME="movies" \
 13     NEO4J_PASSWORD="movies" \
 14     NEO4J_SSL="ON" \

[ardatan]

Those environment variables are not enough for me.
I need a reproduction that I can run locally at least.
https://dev.to/dannyhw/what-is-a-reproduction-3kjb

[f1-outsourcing]

This a Dockerfile

#
# Stage 0: builder
#
FROM alpine:3.20 as builder

# environment settings for this application
ENV NPM_USER="npm" \
    NPM_UID=10035 \
    NPM_DATA_DIR="/usr/local/sofa" \
    NPM_HOME="/usr/local/sofa" \
    NPM_CRT_DIR="/etc/ssl/certs" \
    NPM_KEY_DIR="/etc/ssl/private" \
    NEO4J_URI="bolt://demo.neo4jlabs.com:7687" \
    NEO4J_DB="movies" \
    NEO4J_USERNAME="movies" \
    NEO4J_PASSWORD="movies" \
    NEO4J_SSL="ON" \
    SOFA_PORT=4000 \
    SOFA_LOGGER_LEVEL=info \
    SOFA_HEADERAUTH= \
    NPM_LOGGING=console 

# create user/group
RUN deluser $NPM_USER || echo "no user $NPM_USER" \
    && delgroup $NPM_USER || echo "no group $NPM_USER"
RUN addgroup $NPM_USER -g $NPM_UID \
    && adduser $NPM_USER -u $NPM_UID -G $NPM_USER -S -g "Sofa server" -h $NPM_DATA_DIR

# install necessary packages
RUN apk add bash ca-certificates python3 make g++ npm --no-cache

# install -ca
RUN update-ca-certificates

# copy configuration files
COPY index-demo.ts ${NPM_HOME}/

RUN cd ${NPM_HOME}/ \
    && npm config set fund false --location=global  \
    && npm install --include=optional --omit=dev tsx \
    && npm install --include=optional --omit=dev sofa-api \
    && npm install --include=optional --omit=dev express schema \
    && npm install --include=optional --omit=dev dotenv \
    && npm install --include=optional --omit=dev morgan \
    && npm install --include=optional --omit=dev winston winston-syslog \
    && npm install --include=optional --omit=dev unix-dgram \
    && npm install --include=optional --omit=dev helmet \
    && npm install --include=optional --omit=dev http \
    && npm install --include=optional --omit=dev https \
    && npm install --include=optional --omit=dev neo4j-driver \
    && npm install --include=optional --omit=dev @neo4j/graphql \
    && npm install --include=optional --omit=dev keycloak-connect \
    && npm install --include=optional --omit=dev express-session @types/express @types/express-session \
    && npm install --include=optional --omit=dev global-agent socks-proxy-agent \
    && find node_modules -iname "*.md" -delete \
    && find node_modules -iname "*.log" -delete \
    && rm -rf node_modules/chromedriver

# change permissions
RUN chown $NPM_USER ${NPM_HOME}/keycloak.json \
    && chown $NPM_USER ${NPM_HOME}/index.ts \ 
    && chown $NPM_USER -R ${NPM_KEY_DIR}/ \ 
    && chown $NPM_USER ${NPM_CRT_DIR}/ \ 
    && chown $NPM_USER ${NPM_CRT_DIR}/*.mesos.crt


#
# Stage 1: runtime
#
FROM alpine:3.20

# environment settings for this application
ENV NPM_USER="npm" \
    NPM_UID=10035 \
    NPM_DATA_DIR="/usr/local/sofa" \
    NPM_HOME="/usr/local/sofa" \
    NPM_CRT_DIR="/etc/ssl/certs" \
    NPM_KEY_DIR="/etc/ssl/private" \
    NEO4J_URI="bolt://demo.neo4jlabs.com:7687" \
    NEO4J_DB="movies" \
    NEO4J_USERNAME="movies" \
    NEO4J_PASSWORD="movies" \
    NEO4J_SSL="ON" \
    SOFA_PORT=4000 \
    SOFA_LOGGER_LEVEL=info \
    SOFA_HEADERAUTH= \
    NPM_LOGGING=console

# create user/group
RUN deluser $NPM_USER || echo "no user $NPM_USER" \
    && delgroup $NPM_USER || echo "no group $NPM_USER"
RUN addgroup $NPM_USER -g $NPM_UID \
    && adduser $NPM_USER -u $NPM_UID -G $NPM_USER -S -g "Sofa server" -h $NPM_DATA_DIR

# install necessary packages
RUN apk add bash ca-certificates npm --no-cache

# install -ca
RUN update-ca-certificates

# copy configuration files
COPY --from=builder ${NPM_HOME} ${NPM_HOME}
COPY index-demo.ts ${NPM_HOME}/


# change permissions
RUN chown $NPM_USER ${NPM_HOME}/keycloak.json \
    && chown $NPM_USER ${NPM_HOME}/index.ts \
    && chown $NPM_USER -R ${NPM_KEY_DIR}/ \
    && chown $NPM_USER ${NPM_CRT_DIR}/ \
    && chown $NPM_USER ${NPM_CRT_DIR}/*.mesos.crt

CMD ["/sbin/entrypoint.sh"]

index-demo.ts

import dotenv from "dotenv";
import { Neo4jGraphQL } from "@neo4j/graphql";
import neo4j from "neo4j-driver";
import express from "express";
import session from 'express-session';
import { useSofa } from "sofa-api";
import { createServer } from "http";
import { createServer as createHttpsServer } from "https";
import helmet from "helmet";
import winston from "winston";
import "winston-syslog";
import morgan from "morgan";
import Keycloak, { KeycloakConfig } from "keycloak-connect";
import { SocksProxyAgent } from 'socks-proxy-agent';
import fs from "fs";
import path from "path";

// Define your type definitions (No raw queries)
let baseTypeDefs = `

type Person @node {
    name: String
    born: BigInt
}

type Movie @node {
    title: String
    release: BigInt
    votes: BigInt
}

type Query {
    databaseStatus: String
    actors: [Person]
}

schema {
    query: Query
}

`;

dotenv.config();

const {
    PORT0,
    NEO4J_URI,
    NEO4J_DB,
    NEO4J_USERNAME,
    NEO4J_PASSWORD,
    NEO4J_SSL,
    SOFA_PORT,
    SOFA_LOGGER_LEVEL,
    SOFA_HEADERAUTH,
    NPM_CRT,
    NPM_KEY,
    NPM_CRT_DIR,
    NPM_KEY_DIR,
    NPM_LOGGING,
    SOCKS_PROXY_HOST,
} = process.env;

const sofaport = SOFA_PORT || PORT0 || 4000;
const sofaheadauth = SOFA_HEADERAUTH || "";
const neo4juri = NEO4J_URI || "bolt://demo.neo4jlabs.com:7687";
const neo4jdb = NEO4J_DB || "movies";
const neo4juser = NEO4J_USERNAME || "movies";
const neo4jpass = NEO4J_PASSWORD || "movies";
const neo4jssl = NEO4J_SSL || "ON";
const npmcrt = NPM_CRT || '';
const npmkey = NPM_KEY || '';
const useSyslog = NPM_LOGGING === 'syslog';
const loglevel = SOFA_LOGGER_LEVEL || 'info';
const helmetEnabled = true;
const keycloakEnabled = true;
const socksproxyhost = SOCKS_PROXY_HOST || ''; 
const autotypedefnodes = true;
const autotypedefrels = true;

// Custom logger
let logger = winston.Logger;

if (useSyslog) {
    // Create a Winston logger that logs to syslog (/dev/log)
    const winston = require('winston');
    const syslogFormat = winston.format.combine(
        winston.format.timestamp(),
        winston.format.printf(({ timestamp, level, message }) => {
            return `${level} ${message}`;
        })
    );
    logger = winston.createLogger({
        format: syslogFormat,
        transports: [
            new winston.transports.Syslog({
                protocol: "unix",
                path: '/dev/log',
                host: '',
                level: loglevel,
                facility: 'local0',
                app_name: 'sofa',
            })
        ]
    });
} else {
    // Create a Winston logger that logs to the console
    logger = winston.createLogger({
        format: winston.format.colorize(),
        transports: [
            new winston.transports.Console({
                level: 'info',
                format: winston.format.simple(),
            })
        ]
    });
    logger.info('logging to console');
}


// Set up Neo4j driver with explicit database selection and custom logger
const driver = neo4j.driver(
    neo4juri,
    neo4j.auth.basic(neo4juser, neo4jpass),
    {
        encrypted: "ENCRYPTION_" + neo4jssl,
        connectionTimeout: 30000,
        logger: (level: string, message: string) => {
            switch (level) {
                case 'error':
                    logger.error(message);
                    break;
                case 'warn':
                    logger.warn(message);
                    break;
                case 'info':
                    logger.info(message);
                    break;
                case 'debug':
                    logger.debug(message);
                    break;
                default:
                    logger.info(message);
                    break;
            }
        },

    }
);

async function main() {
    logger.info("starting sofa");

    try {
        const typeDefs = baseTypeDefs; 

        // Create a Neo4jGraphQL instance
        const neoSchema = new Neo4jGraphQL({
            typeDefs,
            driver,
            resolvers: {
                Query: {
                    databaseStatus: async () => {
                        try {
                            const session = driver.session({ database: neo4jdb });
                            await session.run("RETURN 1");
                            session.close();
                            return "Database is connected";
                        } catch (error) {
                            logger.error("Database connection error:", error);
                            return "Database connection error";
                        }
                    }
                }
            }
        });

        const schema = await neoSchema.getSchema();

        // Create express app
        const app = express();


        // Set up SOFA API with context handling
        const sofa = useSofa({
            schema,
            basePath: "/api",
            openAPI: {
                info: {
                    title: 'Example API',
                    version: '3.0.0',
                },
                endpoint: '/openapi.json',
            },
            swaggerUI: {
                path: '/docs',
            },
            execute: require("graphql").execute,
            subscribe: require("graphql").subscribe,
            onError: (error, req) => {
                logger.error(`on ${req.method} ${req.url}: ${error.message}`);
            },
            context: ({ req }) => {
                // Ensure execution context is correctly set for each request
                logger.info(`execution context set for request to ${req.url}`);
                return {
                    req,
                    sessionConfig: {
                        database: neo4jdb,
                    }
                };
            },
        });

        app.use("/api", sofa);

        // Test connection route to ensure database access
        app.get("/test-connection", async (req, res) => {
            try {
                const session = driver.session({ database: neo4jdb });
                const result = await session.run(`MATCH (m) RETURN m LIMIT 1`);
                session.close();
                logger.info("Connection test result:", result.records);
                res.json({ message: "Connection successful", data: result.records });
            } catch (error) {
                logger.error("Connection test error:", error);
                res.status(500).json({ error: error.message });
            }
        });

        // Health check route
        app.get('/health', (req, res) => {
            // You can add more comprehensive checks here, like checking database connections or other services
            res.status(200).json({ status: 'Healthy' });
        });

        // Start the server
        let credentials = null; 

        if (npmcrt && npmkey) {
            logger.info(`loading ssl ${npmcrt}`);
            const npmcrtfile = (NPM_CRT_DIR || '.') + '/' + npmcrt;
            const npmkeyfile = (NPM_KEY_DIR || '.') + '/' + npmkey;
            const crt = fs.readFileSync(npmcrtfile, 'utf8');
            const key = fs.readFileSync(npmkeyfile, 'utf8');

            credentials = { key: key, cert: crt };

        }

        const server = credentials 
            ? createHttpsServer(credentials, app)
            : createServer(app);

        server.listen(sofaport, '0.0.0.0', () => {
            const addressInfo = server.address();

            if (typeof addressInfo === 'string') {
                console.log(`Server is running and listening on ${addressInfo}`);
                logger.info(`Server is running and listening on ${addressInfo}`);
            } else if (addressInfo && addressInfo.address) {
                console.log(`Server is running and listening on IP ${addressInfo.address} and port ${addressInfo.port}`);
                logger.info(`Server is running and listening on IP ${addressInfo.address} and port ${addressInfo.port}`);
            }

        });
    } catch (error) {
        console.error('Error during setup:', error);
    }
}

main().catch((error) => {
    console.error("Error starting the server:", error);
});

[ardatan]

We don't have such an example for that.

[f1-outsourcing]

Ok but you worked on this software, you know it architecture so you can tell me what class/methods or whatever I need to look at not?

[f1-outsourcing]

And what is with all these other bugs or weird results I reported, are these now being checked? Like this one

#1710

or this one

#1701

[ardatan]

I need a reproduction on CodeSandbox or at least in a repo like I said there and here.

[f1-outsourcing]

I send you the docker image and the complete file. I asked 2 times if it was ok.

[f1-outsourcing]

@ardatan So what is up with all this, or you just writing this when you don't feel like doing anything?

[f1-outsourcing]

Oh ok that is nice, that was not clear to me. So is the index-demo.ts good enough? It is a stripped down version of what I have so it should behave exactly the same.

[f1-outsourcing]

Other than that. I am also willing to pay a bit for support, I have tried to reach out to this company https://the-guild.dev/ via chat and email, but did not get any response. Currently I wasted a bit of hours on a developer that did not really get the concept of sofa and was just hard coding queries.
I am also curious if these 'bugs' I found are not maybe just related to the neo4j driver, I can't really imagine that I am the first that notices this.

[Urigo]

@f1-outsourcing please post a reproduction on a GitHub repo or on Code Sandbox

[f1-outsourcing]

?? I don't use a repo for just 2 files and I also don't use code sandbox. Maybe you give me your code sandbox, because I doubt if it is allowed to install npm modules and do external requests.

[f1-outsourcing]

Maybe you should get a developer to answer this, because you do not seem to get that everything you need is in these two files.

[f1-outsourcing]

There is some saying "Insanity Is Doing the Same Thing Over and Over Again and Expecting Different Results" maybe take this into account when repeating the same constantly. But I start to get now why there seem to be so many bugs, and nobody is using this.

[f1-outsourcing]

Could your add to your example how one can add a property before executing an insert/update query? Eg add _created timestamp property to the type Comment so this is stored in the database.

type Comment {
  id: ID
  text: String
}

@Urigo @ardatan

Can you answer this, this has even nothing to do with a sandbox. Unless you also do not work any more with SOFA and don't have it local.

[f1-outsourcing]

@Urigo @ardatan I am also willing to pay as I wrote earlier. I don't really have the time for this retirement home attitude/approach. I have some minor changes that need to be done, that probably are quick fix for someone that has experience with sofa. Maybe 2-3 hours.