@serve.zone/gitops 2.13.1

package/readme.md

@@ -0,0 +1,177 @@
+# @serve.zone/gitops
+
+GitOps is a self-hosted operations dashboard for Gitea and GitLab. It connects provider instances, centralizes CI/CD secret visibility, mirrors repositories, watches pipelines, streams job logs, and can publish repository documentation into BookStack from one Node.js-powered web app.
+
+## Issue Reporting and Security
+
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
+
+## What It Does
+
+- Connects to Gitea and GitLab through provider adapters with a shared project, group, secret, pipeline, and file-content interface.
+- Stores provider tokens and BookStack job tokens through `@push.rocks/smartsecret`, using OS keychain support where available and an encrypted fallback otherwise.
+- Serves a bundled Lit/dees-catalog single page app through `@api.global/typedserver` with TypedRequest handlers for all backend actions.
+- Scans project and group CI/CD secrets into an embedded SmartMongo cache and refreshes that cache on startup and every 24 hours.
+- Mirrors repositories from a source connection to a target connection with group offset support, metadata sync, stale repository handling, and live sync logs.
+- Manages reusable secret definitions that can be pushed to selected project or group targets.
+- Runs scheduled jobs, currently focused on syncing `readme.md`, `changelog.md`, and `docs/*.md` content into BookStack shelves, books, and pages.
+- Receives provider webhooks at `POST /webhook/:connectionId` and broadcasts events to connected browser clients.
+
+## Runtime Shape
+
+GitOps is a Node.js service packaged as an npm module. Deno is used only for compiling self-contained binary targets through `@git.zone/tsdeno`.
+
+| Area | Implementation |
+| --- | --- |
+| Entry point | `cli.js`, default command `server` |
+| Backend | `ts/`, centered around `GitopsApp` |
+| Web server | `ts/opsserver/`, TypedServer plus TypedRequest handlers |
+| Shared contracts | `ts_interfaces/` data and request interfaces |
+| Frontend | `ts_web/`, Lit web components and smartstate |
+| Build output | `dist_ts/`, `dist_ts_interfaces/`, and `dist_serve/` generated by `tsbuild` and `tsbundle` |
+| Persistent storage | `~/.serve.zone/gitops/storage/` |
+| Cache database | `~/.serve.zone/gitops/tsmdb/` |
+
+## Installation and Usage
+
+Install the package through pnpm and start the public `gitops` binary:
+
+```bash
+pnpm add -g @serve.zone/gitops
+GITOPS_PORT=3000 gitops server
+```
+
+For local source runs, use the checked-in Node entrypoint:
+
+```bash
+node ./cli.js server
+GITOPS_PORT=3001 node ./cli.js server
+```
+
+The package exports the application API and shared request/data contracts for typed integrations:
+
+```typescript
+import { GitopsApp } from '@serve.zone/gitops';
+import type * as gitopsInterfaces from '@serve.zone/gitops/interfaces';
+```
+
+## Key Components
+
+| Component | Role |
+| --- | --- |
+| `GitopsApp` | Starts storage, provider connections, cache, sync, jobs, managed secrets, scans, and the OpsServer. |
+| `ConnectionManager` | Persists Gitea/GitLab connections, migrates old plaintext tokens into SmartSecret, and background-checks connection health. |
+| `GiteaProvider` / `GitLabProvider` | Provider-specific adapters behind a shared `BaseProvider` interface. |
+| `SecretsScanService` | Fetches project and group secrets in batches and upserts them into cached SmartData documents. |
+| `SyncManager` | Mirrors repositories with bare git clones, source/target path mapping, deletion safeguards, branch/default-branch handling, and metadata sync. |
+| `ManagedSecretsManager` | Stores define-once secret records and pushes them to selected project or group targets. |
+| `JobManager` | Stores scheduled jobs, starts interval timers, masks persisted secrets, and dispatches job execution to registered runners. |
+| `AutoBookstackDocsRunner` | Maps git groups to BookStack shelves, repos to books, and markdown files to pages with content hashes to avoid noisy updates. |
+
+## Server Configuration
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `GITOPS_PORT` | `3000` | HTTP and WebSocket server port. |
+| `GITOPS_ADMIN_USERNAME` | `admin` | Dashboard login username. |
+| `GITOPS_ADMIN_PASSWORD` | `admin` | Dashboard login password. |
+
+Provider connections, sync configs, jobs, managed secrets, and action logs are persisted as JSON records below `~/.serve.zone/gitops/storage/`. Cached projects and secrets live in the embedded SmartMongo directory below `~/.serve.zone/gitops/tsmdb/`.
+
+## API Surface
+
+The backend exposes TypedRequest methods through `/typedrequest` and a custom webhook route. The important handler groups are:
+
+| Handler | Examples |
+| --- | --- |
+| Admin | `adminLogin`, `adminLogout`, `verifyIdentity` |
+| Connections | `getConnections`, `createConnection`, `updateConnection`, `testConnection`, `pauseConnection`, `deleteConnection` |
+| Projects and Groups | Provider browsing with search/pagination style request contracts |
+| Secrets | Cached and direct project/group secret CRUD |
+| Managed Secrets | Definition CRUD plus push-to-target operations |
+| Pipelines and Logs | Pipeline listing, jobs, retry/cancel, and raw job log fetches |
+| Sync | Sync config CRUD, preview, trigger, status, and logs |
+| Jobs | Scheduled job CRUD, trigger, pause/resume, and logs |
+| Webhooks | `POST /webhook/:connectionId` for provider event fan-out |
+
+## Auto BookStack Documentation
+
+The current scheduled job type is `autobookstackdocs`. It reads markdown documentation from connected Git providers and publishes it into BookStack.
+
+| Git source | BookStack target |
+| --- | --- |
+| Group or organization | Shelf |
+| Repository | Book named `@group/repo` |
+| `readme.md` or `changelog.md` | Page named `<file> for @group/repo` |
+| `docs/*.md` | Page named `<path> for @group/repo` |
+
+Notable behavior from the runner implementation:
+
+- SHA-256 hashes are persisted per job so unchanged pages are skipped.
+- Optional delete propagation can remove stale shelves, books, and pages.
+- Optional visibility sync can restrict private/internal repos in BookStack.
+- Tags are collected from git topics and `package.json` keywords.
+- Root headings that duplicate the book or page context are stripped before publication.
+
+## Development
+
+```bash
+pnpm install
+pnpm build
+pnpm test
+pnpm run startTs
+```
+
+Useful direct commands:
+
+```bash
+node ./cli.js server
+GITOPS_PORT=3001 node ./cli.js server
+pnpm run build:binary
+pnpm run build:docker
+pnpm run watch
+```
+
+## Project Map
+
+```text
+gitops/
+├── cli.js
+├── cli.ts.js
+├── binary/
+├── deno.json
+├── package.json
+├── tsconfig.json
+├── html/
+├── ts/
+│   ├── classes/
+│   ├── cache/
+│   ├── opsserver/
+│   ├── providers/
+│   └── storage/
+├── ts_interfaces/
+├── ts_web/
+├── dist_serve/
+└── test/
+```
+
+## License and Legal Information
+
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [license](./license) file.
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
+
+### Company Information
+
+Task Venture Capital GmbH<br>
+Registered at District Court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

package/readme.todo.md

@@ -0,0 +1,3 @@
+# GitOps TODOs
+
+- [ ] Webhook HMAC signature verification (X-Gitea-Signature / X-Gitlab-Token) — currently accepts all POSTs

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@serve.zone/gitops',
+  version: '2.13.1',
+  description: 'GitOps management app for Gitea and GitLab - manage secrets, browse projects, view CI pipelines, and stream build logs'
+}

package/ts/cache/classes.cache.cleaner.ts

@@ -0,0 +1,69 @@
+import { logger } from '../logging.js';
+import { unrefTimer } from '../timers.js';
+import type { CacheDb } from './classes.cachedb.js';
+
+// deno-lint-ignore no-explicit-any
+type DocumentClass = { getInstances: (filter: any) => Promise<{ delete: () => Promise<void> }[]> };
+
+const DEFAULT_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+
+/**
+ * Periodically cleans up expired cached documents.
+ */
+export class CacheCleaner {
+  private intervalId: ReturnType<typeof setInterval> | null = null;
+  private intervalMs: number;
+  private documentClasses: DocumentClass[] = [];
+  private cacheDb: CacheDb;
+
+  constructor(cacheDb: CacheDb, intervalMs = DEFAULT_INTERVAL_MS) {
+    this.cacheDb = cacheDb;
+    this.intervalMs = intervalMs;
+  }
+
+  /** Register a document class for cleanup */
+  registerClass(cls: DocumentClass): void {
+    this.documentClasses.push(cls);
+  }
+
+  start(): void {
+    if (this.intervalId !== null) return;
+    this.intervalId = setInterval(() => {
+      this.clean().catch((err) => {
+        logger.error(`CacheCleaner error: ${err}`);
+      });
+    }, this.intervalMs);
+    // Unref so the interval doesn't prevent process exit
+    unrefTimer(this.intervalId);
+    logger.debug(`CacheCleaner started (interval: ${this.intervalMs}ms)`);
+  }
+
+  stop(): void {
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      logger.debug('CacheCleaner stopped');
+    }
+  }
+
+  /** Run a single cleanup pass */
+  async clean(): Promise<number> {
+    const now = Date.now();
+    let totalDeleted = 0;
+    for (const cls of this.documentClasses) {
+      try {
+        const expired = await cls.getInstances({ expiresAt: { $lt: now } });
+        for (const doc of expired) {
+          await doc.delete();
+          totalDeleted++;
+        }
+      } catch (err) {
+        logger.error(`CacheCleaner: failed to clean class: ${err}`);
+      }
+    }
+    if (totalDeleted > 0) {
+      logger.debug(`CacheCleaner: deleted ${totalDeleted} expired document(s)`);
+    }
+    return totalDeleted;
+  }
+}

package/ts/cache/classes.cached.document.ts

@@ -0,0 +1,57 @@
+import * as plugins from '../plugins.js';
+
+/** TTL duration constants in milliseconds */
+export const TTL = {
+  MINUTES_5: 5 * 60 * 1000,
+  HOURS_1: 60 * 60 * 1000,
+  HOURS_24: 24 * 60 * 60 * 1000,
+  DAYS_7: 7 * 24 * 60 * 60 * 1000,
+  DAYS_30: 30 * 24 * 60 * 60 * 1000,
+  DAYS_90: 90 * 24 * 60 * 60 * 1000,
+} as const;
+
+/**
+ * Abstract base class for cached documents with TTL support.
+ * Extend this class and add @Collection decorator pointing to your CacheDb.
+ */
+export abstract class CachedDocument<
+  T extends CachedDocument<T>,
+> extends plugins.smartdata.SmartDataDbDoc<T, T> {
+  @plugins.smartdata.svDb()
+  public createdAt: number = Date.now();
+
+  @plugins.smartdata.svDb()
+  public expiresAt: number = Date.now() + TTL.HOURS_1;
+
+  @plugins.smartdata.svDb()
+  public lastAccessedAt: number = Date.now();
+
+  constructor() {
+    super();
+  }
+
+  /** Set TTL in milliseconds from now */
+  setTTL(ms: number): void {
+    this.expiresAt = Date.now() + ms;
+  }
+
+  /** Set TTL in days from now */
+  setTTLDays(days: number): void {
+    this.setTTL(days * 24 * 60 * 60 * 1000);
+  }
+
+  /** Set TTL in hours from now */
+  setTTLHours(hours: number): void {
+    this.setTTL(hours * 60 * 60 * 1000);
+  }
+
+  /** Check if this document has expired */
+  isExpired(): boolean {
+    return Date.now() > this.expiresAt;
+  }
+
+  /** Update last accessed timestamp */
+  touch(): void {
+    this.lastAccessedAt = Date.now();
+  }
+}

package/ts/cache/classes.cachedb.ts

@@ -0,0 +1,72 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logging.js';
+
+export interface ICacheDbOptions {
+  storagePath?: string;
+  dbName?: string;
+  debug?: boolean;
+}
+
+/**
+ * Singleton wrapper around LocalTsmDb + SmartdataDb.
+ * Provides a managed MongoDB-compatible cache database.
+ */
+export class CacheDb {
+  private static instance: CacheDb | null = null;
+
+  private smartMongo: InstanceType<typeof plugins.smartmongo.SmartMongo> | null = null;
+  private smartdataDb: InstanceType<typeof plugins.smartdata.SmartdataDb> | null = null;
+  private options: Required<ICacheDbOptions>;
+
+  private constructor(options: ICacheDbOptions = {}) {
+    this.options = {
+      storagePath: options.storagePath ?? './.nogit/cachedb',
+      dbName: options.dbName ?? 'gitops_cache',
+      debug: options.debug ?? false,
+    };
+  }
+
+  static getInstance(options?: ICacheDbOptions): CacheDb {
+    if (!CacheDb.instance) {
+      CacheDb.instance = new CacheDb(options);
+    }
+    return CacheDb.instance;
+  }
+
+  static resetInstance(): void {
+    CacheDb.instance = null;
+  }
+
+  async start(): Promise<void> {
+    logger.info('Starting CacheDb...');
+    this.smartMongo = await plugins.smartmongo.SmartMongo.createAndStart();
+    const mongoDescriptor = await this.smartMongo.getMongoDescriptor();
+
+    this.smartdataDb = new plugins.smartdata.SmartdataDb({
+      mongoDbUrl: mongoDescriptor.mongoDbUrl,
+      mongoDbName: this.options.dbName,
+    });
+    await this.smartdataDb.init();
+    logger.success(`CacheDb started (db: ${this.options.dbName})`);
+  }
+
+  async stop(): Promise<void> {
+    logger.info('Stopping CacheDb...');
+    if (this.smartdataDb) {
+      await this.smartdataDb.close();
+      this.smartdataDb = null;
+    }
+    if (this.smartMongo) {
+      await this.smartMongo.stop();
+      this.smartMongo = null;
+    }
+    logger.success('CacheDb stopped');
+  }
+
+  getDb(): InstanceType<typeof plugins.smartdata.SmartdataDb> {
+    if (!this.smartdataDb) {
+      throw new Error('CacheDb not started. Call start() first.');
+    }
+    return this.smartdataDb;
+  }
+}

package/ts/cache/classes.secrets.scan.service.ts

@@ -0,0 +1,267 @@
+import { logger } from '../logging.js';
+import type { ConnectionManager } from '../classes/connectionmanager.js';
+import { CachedSecret } from './documents/classes.cached.secret.js';
+import { TTL } from './classes.cached.document.js';
+import type { ISecret } from '../../ts_interfaces/data/secret.js';
+
+export interface IScanResult {
+  connectionsScanned: number;
+  secretsFound: number;
+  errors: string[];
+  durationMs: number;
+}
+
+/**
+ * Centralized secrets scanning service. Fetches all secrets from all
+ * connections and upserts them into the CachedSecret collection.
+ */
+export class SecretsScanService {
+  public lastScanTimestamp: number = 0;
+  public lastScanResult: IScanResult | null = null;
+  public isScanning: boolean = false;
+
+  private connectionManager: ConnectionManager;
+
+  constructor(connectionManager: ConnectionManager) {
+    this.connectionManager = connectionManager;
+  }
+
+  /**
+   * Upsert a single secret into the cache. If a doc with the same composite ID
+   * already exists, update it in place; otherwise insert a new one.
+   */
+  private async upsertSecret(secret: ISecret): Promise<void> {
+    const id = CachedSecret.buildId(secret.connectionId, secret.scope, secret.scopeId, secret.key);
+    const existing = await CachedSecret.getInstance({ id });
+    if (existing) {
+      existing.value = secret.value;
+      existing.protected = secret.protected;
+      existing.masked = secret.masked;
+      existing.environment = secret.environment;
+      existing.scopeName = secret.scopeName;
+      existing.setTTL(TTL.HOURS_24);
+      await existing.save();
+    } else {
+      const doc = CachedSecret.fromISecret(secret);
+      await doc.save();
+    }
+  }
+
+  /**
+   * Save an array of secrets to cache using upsert logic.
+   * Best-effort: individual failures are silently ignored.
+   */
+  async saveSecrets(secrets: ISecret[]): Promise<void> {
+    for (const secret of secrets) {
+      try {
+        await this.upsertSecret(secret);
+      } catch {
+        // Best-effort caching
+      }
+    }
+  }
+
+  /**
+   * Full scan: iterate all connections, fetch all projects+groups,
+   * fetch all secrets per entity, upsert CachedSecret docs.
+   */
+  async fullScan(): Promise<IScanResult> {
+    if (this.isScanning) {
+      return {
+        connectionsScanned: 0,
+        secretsFound: 0,
+        errors: ['Scan already in progress'],
+        durationMs: 0,
+      };
+    }
+
+    this.isScanning = true;
+    const startTime = Date.now();
+    const errors: string[] = [];
+    let totalSecrets = 0;
+    let connectionsScanned = 0;
+
+    try {
+      const connections = this.connectionManager.getConnections();
+      for (const conn of connections) {
+        if (conn.status === 'paused') continue;
+        try {
+          const provider = this.connectionManager.getProvider(conn.id);
+          connectionsScanned++;
+
+          // Scan project secrets
+          try {
+            const projects = await provider.getProjects();
+            for (let i = 0; i < projects.length; i += 5) {
+              const batch = projects.slice(i, i + 5);
+              const results = await Promise.allSettled(
+                batch.map(async (p) => {
+                  const secrets = await provider.getProjectSecrets(p.id);
+                  return secrets.map((s) => ({
+                    ...s,
+                    scope: 'project' as const,
+                    scopeId: p.id,
+                    scopeName: p.fullPath || p.name,
+                    connectionId: conn.id,
+                  }));
+                }),
+              );
+              for (const result of results) {
+                if (result.status === 'fulfilled') {
+                  for (const secret of result.value) {
+                    try {
+                      await this.upsertSecret(secret);
+                      totalSecrets++;
+                    } catch (err) {
+                      errors.push(`Save secret ${secret.key}: ${err}`);
+                    }
+                  }
+                } else {
+                  errors.push(`Fetch project secrets: ${result.reason}`);
+                }
+              }
+            }
+          } catch (err) {
+            errors.push(`Fetch projects for ${conn.id}: ${err}`);
+          }
+
+          // Scan group secrets
+          try {
+            const groups = await provider.getGroups();
+            for (let i = 0; i < groups.length; i += 5) {
+              const batch = groups.slice(i, i + 5);
+              const results = await Promise.allSettled(
+                batch.map(async (g) => {
+                  const secrets = await provider.getGroupSecrets(g.id);
+                  return secrets.map((s) => ({
+                    ...s,
+                    scope: 'group' as const,
+                    scopeId: g.id,
+                    scopeName: g.fullPath || g.name,
+                    connectionId: conn.id,
+                  }));
+                }),
+              );
+              for (const result of results) {
+                if (result.status === 'fulfilled') {
+                  for (const secret of result.value) {
+                    try {
+                      await this.upsertSecret(secret);
+                      totalSecrets++;
+                    } catch (err) {
+                      errors.push(`Save secret ${secret.key}: ${err}`);
+                    }
+                  }
+                } else {
+                  errors.push(`Fetch group secrets: ${result.reason}`);
+                }
+              }
+            }
+          } catch (err) {
+            errors.push(`Fetch groups for ${conn.id}: ${err}`);
+          }
+        } catch (err) {
+          errors.push(`Connection ${conn.id}: ${err}`);
+        }
+      }
+    } finally {
+      this.isScanning = false;
+    }
+
+    const result: IScanResult = {
+      connectionsScanned,
+      secretsFound: totalSecrets,
+      errors,
+      durationMs: Date.now() - startTime,
+    };
+
+    this.lastScanTimestamp = Date.now();
+    this.lastScanResult = result;
+
+    logger.info(
+      `Secrets scan complete: ${totalSecrets} secrets from ${connectionsScanned} connections in ${result.durationMs}ms` +
+        (errors.length > 0 ? ` (${errors.length} errors)` : ''),
+    );
+
+    return result;
+  }
+
+  /**
+   * Scan a single entity: delete existing cached secrets for that entity,
+   * fetch fresh from provider, and save to cache.
+   */
+  async scanEntity(
+    connectionId: string,
+    scope: 'project' | 'group',
+    scopeId: string,
+    scopeName?: string,
+  ): Promise<void> {
+    try {
+      // Delete existing cached secrets for this entity
+      const existing = await CachedSecret.getInstances({
+        connectionId,
+        scope,
+        scopeId,
+      });
+      for (const doc of existing) {
+        await doc.delete();
+      }
+
+      // Fetch fresh from provider
+      const provider = this.connectionManager.getProvider(connectionId);
+      const secrets = scope === 'project'
+        ? await provider.getProjectSecrets(scopeId)
+        : await provider.getGroupSecrets(scopeId);
+
+      // Save to cache
+      for (const s of secrets) {
+        const doc = CachedSecret.fromISecret({
+          ...s,
+          scope,
+          scopeId,
+          scopeName: scopeName || s.scopeName || '',
+          connectionId,
+        });
+        await doc.save();
+      }
+    } catch (err) {
+      logger.error(`scanEntity failed for ${connectionId}/${scope}/${scopeId}: ${err}`);
+    }
+  }
+
+  /**
+   * Get cached secrets matching the filter criteria.
+   */
+  async getCachedSecrets(filter: {
+    connectionId: string;
+    scope: 'project' | 'group';
+    scopeId?: string;
+  }): Promise<ISecret[]> {
+    // deno-lint-ignore no-explicit-any
+    const query: any = {
+      connectionId: filter.connectionId,
+      scope: filter.scope,
+    };
+    if (filter.scopeId) {
+      query.scopeId = filter.scopeId;
+    }
+    const docs = await CachedSecret.getInstances(query);
+    // Filter out expired docs
+    const now = Date.now();
+    return docs
+      .filter((d) => d.expiresAt > now)
+      .map((d) => d.toISecret());
+  }
+
+  /**
+   * Check if non-expired cached data exists for the given connection+scope.
+   */
+  async hasCachedData(connectionId: string, scope: 'project' | 'group'): Promise<boolean> {
+    const docs = await CachedSecret.getInstances({
+      connectionId,
+      scope,
+      expiresAt: { $gt: Date.now() },
+    });
+    return docs.length > 0;
+  }
+}

package/ts/cache/documents/classes.cached.project.ts

@@ -0,0 +1,32 @@
+import * as plugins from '../../plugins.js';
+import { CacheDb } from '../classes.cachedb.js';
+import { CachedDocument, TTL } from '../classes.cached.document.js';
+
+/**
+ * Cached project data from git providers. TTL: 5 minutes.
+ */
+@plugins.smartdata.Collection(() => CacheDb.getInstance().getDb())
+export class CachedProject extends CachedDocument<CachedProject> {
+  @plugins.smartdata.unI()
+  public id: string = '';
+
+  @plugins.smartdata.svDb()
+  public connectionId: string = '';
+
+  @plugins.smartdata.svDb()
+  public projectName: string = '';
+
+  @plugins.smartdata.svDb()
+  public projectUrl: string = '';
+
+  @plugins.smartdata.svDb()
+  public description: string = '';
+
+  @plugins.smartdata.svDb()
+  public defaultBranch: string = '';
+
+  constructor() {
+    super();
+    this.setTTL(TTL.MINUTES_5);
+  }
+}