source.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/program/diagnostic.h>
#include <neograph/program/schema.h>
 
#include <cstdint>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph::program {
 
enum class SourceKind { CanonicalJson, CppBuilder, JavaScript };
 
struct ImportRef {
    std::string source_id;
    std::string content_identity;
 
    bool operator==(const ImportRef&) const = default;
};
 
struct SealedJavaScriptModule {
    std::string source_id;
    std::string content_identity;
    std::string source_text;
 
    bool operator==(const SealedJavaScriptModule&) const = default;
};
 
struct SourceMapEntry {
    std::string      generated_pointer;
    SourceCoordinate authored;
 
    bool operator==(const SourceMapEntry&) const = default;
};
 
struct JavaScriptRuntimeIdentity {
    std::string  quickjs_release;
    std::string  quickjs_archive_digest;
    std::string  quickjs_build_options;
    std::string  profile;
    std::uint32_t profile_version = 0;
    std::uint32_t ng_api_version  = 0;
 
    bool operator==(const JavaScriptRuntimeIdentity&) const = default;
};
 
NEOGRAPH_PROGRAM_API std::string_view to_string(SourceKind kind) noexcept;
NEOGRAPH_PROGRAM_API SourceKind       source_kind_from_string(std::string_view value);
NEOGRAPH_PROGRAM_API void             to_json(json& value, const ImportRef& import_ref);
NEOGRAPH_PROGRAM_API void             from_json(const json& value, ImportRef& import_ref);
NEOGRAPH_PROGRAM_API void             to_json(json& value, const SourceMapEntry& entry);
NEOGRAPH_PROGRAM_API void             to_json(json& value,
                                              const SealedJavaScriptModule& module);
NEOGRAPH_PROGRAM_API void             from_json(const json& value,
                                                SealedJavaScriptModule& module);
NEOGRAPH_PROGRAM_API void             from_json(const json& value, SourceMapEntry& entry);
 
class NEOGRAPH_PROGRAM_API ProgramSource {
public:
    static constexpr std::uint32_t    STORAGE_SCHEMA_VERSION            = 1;
    static constexpr std::uint32_t    JAVASCRIPT_PROGRAM_SCHEMA_VERSION =
        LATEST_PROGRAM_SCHEMA_VERSION;
    static constexpr std::uint32_t    JAVASCRIPT_LANGUAGE_VERSION       = 1;
    static constexpr std::uint32_t    JAVASCRIPT_HOST_API_VERSION       = 1;
    static constexpr std::string_view JAVASCRIPT_ENGINE                 = "quickjs";
    static constexpr std::string_view JAVASCRIPT_ENGINE_VERSION         = "2026-06-04";
    static constexpr std::string_view JAVASCRIPT_QUICKJS_ARCHIVE_DIGEST =
        "sha256:b376e839b322978313d929fd20663b11ba58b75df5a46c126dd19ea2fa70ad2a";
    static constexpr std::string_view JAVASCRIPT_QUICKJS_BUILD_OPTIONS =
#if defined(_MSC_VER)
        "CONFIG_VERSION=2026-06-04;QUICKJS_LIBC=disabled;STD_OS=disabled;"
        "DYNAMIC_MODULES=disabled;MSVC_INTRINSICS=disabled;"
        "NEOGRAPH_PLATFORM_PORT=msvc-v1;"
        "NEOGRAPH_PLATFORM_PORT_SHA256="
        "7f12d37b15bce57527714395552d1a0b64c4f5708c48fcb3f787f96ed0d1af51";
#else
        "CONFIG_VERSION=2026-06-04;QUICKJS_LIBC=disabled;STD_OS=disabled;"
        "DYNAMIC_MODULES=disabled";
#endif
    static constexpr std::string_view JAVASCRIPT_PROFILE                = "sealed-v1";
    static constexpr std::uint32_t    JAVASCRIPT_PROFILE_VERSION        = 1;
    static constexpr std::uint32_t    JAVASCRIPT_NG_API_VERSION          = 1;
 
    static JavaScriptRuntimeIdentity default_javascript_runtime_identity();
 
    static ProgramSource from_javascript(std::string                      source_id,
                                         std::string                      source_text,
                                         std::vector<ImportRef>           imports    = {},
                                         std::vector<SourceMapEntry>      source_map = {},
                                         std::vector<SealedJavaScriptModule> sealed_modules = {});
 
    static ProgramSource from_cpp_builder(std::string                 source_id,
                                          std::uint32_t               schema_version,
                                          json                        document,
                                          std::vector<ImportRef>      imports    = {},
                                          std::vector<SourceMapEntry> source_map = {});
 
    static ProgramSource parse(std::string_view stored_bytes);
 
    SourceKind                         kind() const noexcept;
    std::uint32_t                      schema_version() const noexcept;
    const std::string&                 source_id() const noexcept;
    json                               document() const;
    const std::vector<ImportRef>&      imports() const noexcept;
    const std::vector<SourceMapEntry>& source_map() const noexcept;
    const std::vector<SealedJavaScriptModule>& sealed_modules() const noexcept;
    JavaScriptRuntimeIdentity          javascript_runtime_identity() const;
    const std::string& source_hash() const noexcept;
    const std::string& canonical_document() const noexcept;
    std::string        serialize_canonical() const;
 
private:
    struct Impl;
    explicit ProgramSource(std::shared_ptr<const Impl> impl);
    std::shared_ptr<const Impl> impl_;
};
 
}  // namespace neograph::program