Skip to content

Commit 5e4cdab

Browse files
gabor-borosgabor-boros
authored
refactor: flatten repo dir and mount docker config (#388)
Signed-off-by: Gabor Boros <[email protected]>
1 parent 4dde516 commit 5e4cdab

File tree

134 files changed

+15186
-16450
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

134 files changed

+15186
-16450
lines changed

‎.github/workflows/build.yml‎

Lines changed: 24 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -135,9 +135,32 @@ jobs:
135135
run: |
136136
./scripts/setup.sh
137137
sed -i s/CI=false/CI=true/g web/.env.test.local
138+
139+
make start.backend
140+
141+
# Wait for elemo-server to be ready
142+
timeout=15
143+
attempt=0
144+
145+
while [ $attempt -lt $timeout ]; do
146+
if curl -sf "http://127.0.0.1:35478/v1/system/heartbeat" > /dev/null 2>&1; then
147+
echo "elemo-server is ready"
148+
break
149+
fi
150+
echo "Waiting for elemo-server to be ready... (attempt $((attempt + 1))/$timeout)"
151+
sleep 2
152+
attempt=$((attempt + 1))
153+
done
154+
155+
if [ $attempt -eq $timeout ]; then
156+
echo "ERROR: elemo-server did not become ready within $((timeout * 2)) seconds"
157+
docker compose -f deploy/docker/docker-compose.yml ps
158+
docker compose -f deploy/docker/docker-compose.yml logs elemo-server
159+
exit 1
160+
fi
161+
138162
- name: Execute end-to-end tests
139163
run: |
140-
make start.backend
141164
pnpm --prefix web test:e2e --project "${{ matrix.project }}" --shard=${{ matrix.shard }}/${{ matrix.total-shards }}
142165
- name: Upload test results
143166
uses: actions/upload-artifact@v4

‎build/package/Dockerfile‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -39,9 +39,10 @@ FROM gcr.io/distroless/static-debian12:nonroot AS production
3939

4040
ENV TZ=UTC
4141

42-
COPY --chown=nonroot:nonroot assets /opt/opcotech/elemo/assets
43-
COPY --chown=nonroot:nonroot configs /opt/opcotech/elemo/configs
44-
COPY --chown=nonroot:nonroot templates /opt/opcotech/elemo/templates
42+
WORKDIR /opt/opcotech/elemo
43+
44+
COPY --chown=nonroot:nonroot assets/keys /opt/opcotech/elemo/assets/keys
45+
COPY --chown=nonroot:nonroot templates/email /opt/opcotech/elemo/templates/email
4546
COPY --chown=nonroot:nonroot --from=build /usr/bin/elemo /opt/opcotech/elemo/bin/elemo
4647

47-
WORKDIR /opt/opcotech/elemo
48+
CMD ["bin/elemo", "start", "server"]

‎cmd/elemo/cli/root.go‎

Lines changed: 20 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -25,9 +25,7 @@ import (
2525
"github.com/opcotech/elemo/internal/pkg/log"
2626
elemoSMTP "github.com/opcotech/elemo/internal/pkg/smtp"
2727
"github.com/opcotech/elemo/internal/pkg/tracing"
28-
"github.com/opcotech/elemo/internal/repository/neo4j"
29-
"github.com/opcotech/elemo/internal/repository/pg"
30-
"github.com/opcotech/elemo/internal/repository/redis"
28+
"github.com/opcotech/elemo/internal/repository"
3129
)
3230

3331
const (
@@ -148,16 +146,16 @@ func initLogger() {
148146
logger.Info(context.Background(), "config file loaded", log.WithPath(viper.ConfigFileUsed()))
149147
}
150148

151-
func initCacheDatabase() (*redis.Database, error) {
152-
client, err := redis.NewClient(&cfg.CacheDatabase)
149+
func initCacheDatabase() (*repository.RedisDatabase, error) {
150+
client, err := repository.NewRedisClient(&cfg.CacheDatabase)
153151
if err != nil {
154152
return nil, err
155153
}
156154

157-
db, err := redis.NewDatabase(
158-
redis.WithClient(client),
159-
redis.WithDatabaseLogger(logger.Named("redis")),
160-
redis.WithDatabaseTracer(tracer),
155+
db, err := repository.NewRedisDatabase(
156+
repository.WithRedisClient(client),
157+
repository.WithRedisDatabaseLogger(logger.Named("redis")),
158+
repository.WithRedisDatabaseTracer(tracer),
161159
)
162160
if err != nil {
163161
return nil, err
@@ -170,17 +168,17 @@ func initCacheDatabase() (*redis.Database, error) {
170168
return db, nil
171169
}
172170

173-
func initGraphDatabase() (*neo4j.Database, error) {
174-
driver, err := neo4j.NewDriver(&cfg.GraphDatabase)
171+
func initGraphDatabase() (*repository.Neo4jDatabase, error) {
172+
driver, err := repository.NewNeo4jDriver(&cfg.GraphDatabase)
175173
if err != nil {
176174
return nil, err
177175
}
178176

179-
db, err := neo4j.NewDatabase(
180-
neo4j.WithDriver(driver),
181-
neo4j.WithDatabaseName(cfg.GraphDatabase.Database),
182-
neo4j.WithDatabaseLogger(logger.Named("neo4j")),
183-
neo4j.WithDatabaseTracer(tracer),
177+
db, err := repository.NewNeo4jDatabase(
178+
repository.WithNeo4jDriver(driver),
179+
repository.WithNeo4jDatabaseName(cfg.GraphDatabase.Database),
180+
repository.WithNeo4jDatabaseLogger(logger.Named("neo4j")),
181+
repository.WithNeo4jDatabaseTracer(tracer),
184182
)
185183
if err != nil {
186184
return nil, err
@@ -193,16 +191,16 @@ func initGraphDatabase() (*neo4j.Database, error) {
193191
return db, nil
194192
}
195193

196-
func initRelationalDatabase() (*pg.Database, pg.Pool, error) {
197-
pool, err := pg.NewPool(context.Background(), &cfg.RelationalDatabase)
194+
func initRelationalDatabase() (*repository.PGDatabase, repository.PGPool, error) {
195+
pool, err := repository.NewPool(context.Background(), &cfg.RelationalDatabase)
198196
if err != nil {
199197
return nil, nil, err
200198
}
201199

202-
db, err := pg.NewDatabase(
203-
pg.WithDatabasePool(pool),
204-
pg.WithDatabaseLogger(logger.Named("postgres")),
205-
pg.WithDatabaseTracer(tracer),
200+
db, err := repository.NewPGDatabase(
201+
repository.WithDatabasePool(pool),
202+
repository.WithPGDatabaseLogger(logger.Named("postgres")),
203+
repository.WithPGDatabaseTracer(tracer),
206204
)
207205
if err != nil {
208206
return nil, nil, err

‎cmd/elemo/cli/start_server.go‎

Lines changed: 65 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -17,9 +17,6 @@ import (
1717
"github.com/opcotech/elemo/internal/model"
1818
"github.com/opcotech/elemo/internal/queue"
1919
"github.com/opcotech/elemo/internal/repository"
20-
"github.com/opcotech/elemo/internal/repository/neo4j"
21-
"github.com/opcotech/elemo/internal/repository/pg"
22-
"github.com/opcotech/elemo/internal/repository/redis"
2320
"github.com/opcotech/elemo/internal/service"
2421

2522
elemoHttp "github.com/opcotech/elemo/internal/transport/http"
@@ -73,31 +70,31 @@ var startServerCmd = &cobra.Command{
7370
}
7471
}(messageQueue)
7572

76-
licenseRepo, err := neo4j.NewLicenseRepository(
77-
neo4j.WithDatabase(graphDB),
78-
neo4j.WithRepositoryLogger(logger.Named("license_repository")),
79-
neo4j.WithRepositoryTracer(tracer),
73+
licenseRepo, err := repository.NewNeo4jLicenseRepository(
74+
repository.WithNeo4jDatabase(graphDB),
75+
repository.WithNeo4jRepositoryLogger(logger.Named("license_repository")),
76+
repository.WithNeo4jRepositoryTracer(tracer),
8077
)
8178
if err != nil {
8279
logger.Fatal(context.Background(), "failed to initialize license repository", slog.Any("error", err))
8380
}
8481

8582
var permissionRepo repository.PermissionRepository
8683
{
87-
repo, err := neo4j.NewPermissionRepository(
88-
neo4j.WithDatabase(graphDB),
89-
neo4j.WithRepositoryLogger(logger.Named("permission_repository")),
90-
neo4j.WithRepositoryTracer(tracer),
84+
repo, err := repository.NewNeo4jPermissionRepository(
85+
repository.WithNeo4jDatabase(graphDB),
86+
repository.WithNeo4jRepositoryLogger(logger.Named("permission_repository")),
87+
repository.WithNeo4jRepositoryTracer(tracer),
9188
)
9289
if err != nil {
9390
logger.Fatal(context.Background(), "failed to initialize permission repository", slog.Any("error", err))
9491
}
9592

96-
permissionRepo, err = redis.NewCachedPermissionRepository(
93+
permissionRepo, err = repository.NewCachedPermissionRepository(
9794
repo,
98-
redis.WithDatabase(cacheDB),
99-
redis.WithRepositoryLogger(logger.Named("cached_permission_repository")),
100-
redis.WithRepositoryTracer(tracer),
95+
repository.WithRedisDatabase(cacheDB),
96+
repository.WithRedisRepositoryLogger(logger.Named("cached_permission_repository")),
97+
repository.WithRedisRepositoryTracer(tracer),
10198
)
10299
if err != nil {
103100
logger.Fatal(context.Background(), "failed to initialize cached permission repository", slog.Any("error", err))
@@ -106,20 +103,20 @@ var startServerCmd = &cobra.Command{
106103

107104
var organizationRepo repository.OrganizationRepository
108105
{
109-
repo, err := neo4j.NewOrganizationRepository(
110-
neo4j.WithDatabase(graphDB),
111-
neo4j.WithRepositoryLogger(logger.Named("organization_repository")),
112-
neo4j.WithRepositoryTracer(tracer),
106+
repo, err := repository.NewNeo4jOrganizationRepository(
107+
repository.WithNeo4jDatabase(graphDB),
108+
repository.WithNeo4jRepositoryLogger(logger.Named("organization_repository")),
109+
repository.WithNeo4jRepositoryTracer(tracer),
113110
)
114111
if err != nil {
115112
logger.Fatal(context.Background(), "failed to initialize organization repository", slog.Any("error", err))
116113
}
117114

118-
organizationRepo, err = redis.NewCachedOrganizationRepository(
115+
organizationRepo, err = repository.NewCachedOrganizationRepository(
119116
repo,
120-
redis.WithDatabase(cacheDB),
121-
redis.WithRepositoryLogger(logger.Named("cached_organization_repository")),
122-
redis.WithRepositoryTracer(tracer),
117+
repository.WithRedisDatabase(cacheDB),
118+
repository.WithRedisRepositoryLogger(logger.Named("cached_organization_repository")),
119+
repository.WithRedisRepositoryTracer(tracer),
123120
)
124121
if err != nil {
125122
logger.Fatal(context.Background(), "failed to initialize cached organization repository", slog.Any("error", err))
@@ -128,20 +125,20 @@ var startServerCmd = &cobra.Command{
128125

129126
var roleRepo repository.RoleRepository
130127
{
131-
repo, err := neo4j.NewRoleRepository(
132-
neo4j.WithDatabase(graphDB),
133-
neo4j.WithRepositoryLogger(logger.Named("role_repository")),
134-
neo4j.WithRepositoryTracer(tracer),
128+
repo, err := repository.NewNeo4jRoleRepository(
129+
repository.WithNeo4jDatabase(graphDB),
130+
repository.WithNeo4jRepositoryLogger(logger.Named("role_repository")),
131+
repository.WithNeo4jRepositoryTracer(tracer),
135132
)
136133
if err != nil {
137134
logger.Fatal(context.Background(), "failed to initialize role repository", slog.Any("error", err))
138135
}
139136

140-
roleRepo, err = redis.NewCachedRoleRepository(
137+
roleRepo, err = repository.NewCachedRoleRepository(
141138
repo,
142-
redis.WithDatabase(cacheDB),
143-
redis.WithRepositoryLogger(logger.Named("cached_role_repository")),
144-
redis.WithRepositoryTracer(tracer),
139+
repository.WithRedisDatabase(cacheDB),
140+
repository.WithRedisRepositoryLogger(logger.Named("cached_role_repository")),
141+
repository.WithRedisRepositoryTracer(tracer),
145142
)
146143
if err != nil {
147144
logger.Fatal(context.Background(), "failed to initialize cached role repository", slog.Any("error", err))
@@ -150,20 +147,20 @@ var startServerCmd = &cobra.Command{
150147

151148
var userRepo repository.UserRepository
152149
{
153-
repo, err := neo4j.NewUserRepository(
154-
neo4j.WithDatabase(graphDB),
155-
neo4j.WithRepositoryLogger(logger.Named("user_repository")),
156-
neo4j.WithRepositoryTracer(tracer),
150+
repo, err := repository.NewNeo4jUserRepository(
151+
repository.WithNeo4jDatabase(graphDB),
152+
repository.WithNeo4jRepositoryLogger(logger.Named("user_repository")),
153+
repository.WithNeo4jRepositoryTracer(tracer),
157154
)
158155
if err != nil {
159156
logger.Fatal(context.Background(), "failed to initialize user repository", slog.Any("error", err))
160157
}
161158

162-
userRepo, err = redis.NewCachedUserRepository(
159+
userRepo, err = repository.NewCachedUserRepository(
163160
repo,
164-
redis.WithDatabase(cacheDB),
165-
redis.WithRepositoryLogger(logger.Named("cached_user_repository")),
166-
redis.WithRepositoryTracer(tracer),
161+
repository.WithRedisDatabase(cacheDB),
162+
repository.WithRedisRepositoryLogger(logger.Named("cached_user_repository")),
163+
repository.WithRedisRepositoryTracer(tracer),
167164
)
168165
if err != nil {
169166
logger.Fatal(context.Background(), "failed to initialize cached user repository", slog.Any("error", err))
@@ -172,10 +169,10 @@ var startServerCmd = &cobra.Command{
172169

173170
var userTokenRepo repository.UserTokenRepository
174171
{
175-
repo, err := pg.NewUserTokenRepository(
176-
pg.WithDatabase(relDB),
177-
pg.WithRepositoryLogger(logger.Named("user_token_repository")),
178-
pg.WithRepositoryTracer(tracer),
172+
repo, err := repository.NewUserTokenRepository(
173+
repository.WithPGDatabase(relDB),
174+
repository.WithPGRepositoryLogger(logger.Named("user_token_repository")),
175+
repository.WithPGRepositoryTracer(tracer),
179176
)
180177
if err != nil {
181178
logger.Fatal(context.Background(), "failed to initialize user token repository", slog.Any("error", err))
@@ -186,20 +183,20 @@ var startServerCmd = &cobra.Command{
186183

187184
var todoRepo repository.TodoRepository
188185
{
189-
repo, err := neo4j.NewTodoRepository(
190-
neo4j.WithDatabase(graphDB),
191-
neo4j.WithRepositoryLogger(logger.Named("todo_repository")),
192-
neo4j.WithRepositoryTracer(tracer),
186+
repo, err := repository.NewNeo4jTodoRepository(
187+
repository.WithNeo4jDatabase(graphDB),
188+
repository.WithNeo4jRepositoryLogger(logger.Named("todo_repository")),
189+
repository.WithNeo4jRepositoryTracer(tracer),
193190
)
194191
if err != nil {
195192
logger.Fatal(context.Background(), "failed to initialize todo repository", slog.Any("error", err))
196193
}
197194

198-
todoRepo, err = redis.NewCachedTodoRepository(
195+
todoRepo, err = repository.NewCachedTodoRepository(
199196
repo,
200-
redis.WithDatabase(cacheDB),
201-
redis.WithRepositoryLogger(logger.Named("cached_todo_repository")),
202-
redis.WithRepositoryTracer(tracer),
197+
repository.WithRedisDatabase(cacheDB),
198+
repository.WithRedisRepositoryLogger(logger.Named("cached_todo_repository")),
199+
repository.WithRedisRepositoryTracer(tracer),
203200
)
204201
if err != nil {
205202
logger.Fatal(context.Background(), "failed to initialize cached todo repository", slog.Any("error", err))
@@ -208,20 +205,20 @@ var startServerCmd = &cobra.Command{
208205

209206
var namespaceRepo repository.NamespaceRepository
210207
{
211-
repo, err := neo4j.NewNamespaceRepository(
212-
neo4j.WithDatabase(graphDB),
213-
neo4j.WithRepositoryLogger(logger.Named("namespace_repository")),
214-
neo4j.WithRepositoryTracer(tracer),
208+
repo, err := repository.NewNeo4jNamespaceRepository(
209+
repository.WithNeo4jDatabase(graphDB),
210+
repository.WithNeo4jRepositoryLogger(logger.Named("namespace_repository")),
211+
repository.WithNeo4jRepositoryTracer(tracer),
215212
)
216213
if err != nil {
217214
logger.Fatal(context.Background(), "failed to initialize namespace repository", slog.Any("error", err))
218215
}
219216

220-
namespaceRepo, err = redis.NewCachedNamespaceRepository(
217+
namespaceRepo, err = repository.NewCachedNamespaceRepository(
221218
repo,
222-
redis.WithDatabase(cacheDB),
223-
redis.WithRepositoryLogger(logger.Named("cached_namespace_repository")),
224-
redis.WithRepositoryTracer(tracer),
219+
repository.WithRedisDatabase(cacheDB),
220+
repository.WithRedisRepositoryLogger(logger.Named("cached_namespace_repository")),
221+
repository.WithRedisRepositoryTracer(tracer),
225222
)
226223
if err != nil {
227224
logger.Fatal(context.Background(), "failed to initialize cached namespace repository", slog.Any("error", err))
@@ -230,20 +227,20 @@ var startServerCmd = &cobra.Command{
230227

231228
var notificationRepo repository.NotificationRepository
232229
{
233-
repo, err := pg.NewNotificationRepository(
234-
pg.WithDatabase(relDB),
235-
pg.WithRepositoryLogger(logger.Named("notification_repository")),
236-
pg.WithRepositoryTracer(tracer),
230+
repo, err := repository.NewNotificationRepository(
231+
repository.WithPGDatabase(relDB),
232+
repository.WithPGRepositoryLogger(logger.Named("notification_repository")),
233+
repository.WithPGRepositoryTracer(tracer),
237234
)
238235
if err != nil {
239236
logger.Fatal(context.Background(), "failed to initialize notification repository", slog.Any("error", err))
240237
}
241238

242-
notificationRepo, err = redis.NewCachedNotificationRepository(
239+
notificationRepo, err = repository.NewCachedNotificationRepository(
243240
repo,
244-
redis.WithDatabase(cacheDB),
245-
redis.WithRepositoryLogger(logger.Named("cached_notification_repository")),
246-
redis.WithRepositoryTracer(tracer),
241+
repository.WithRedisDatabase(cacheDB),
242+
repository.WithRedisRepositoryLogger(logger.Named("cached_notification_repository")),
243+
repository.WithRedisRepositoryTracer(tracer),
247244
)
248245
if err != nil {
249246
logger.Fatal(context.Background(), "failed to initialize cached notification repository", slog.Any("error", err))
@@ -418,7 +415,7 @@ func init() {
418415
startCmd.AddCommand(startServerCmd)
419416
}
420417

421-
func initAuthProvider(pool pg.Pool) (*authServer.Server, error) {
418+
func initAuthProvider(pool repository.PGPool) (*authServer.Server, error) {
422419
storeLogger := &authStoreLogger{
423420
logger: logger.Named("auth_store"),
424421
}

0 commit comments

Comments
 (0)