├── .shellspec ├── .envrc ├── .mobala ├── version.txt ├── version-commit.lock ├── keep.env ├── steps │ ├── run-gen.sh │ ├── run-test-pb.sh │ ├── run-test-ts.sh │ ├── run-test-cs.sh │ ├── run-test-scala.sh │ ├── run-publish-nuget.sh │ ├── run-coverage.sh │ ├── run-publish-npm.sh │ ├── spec │ │ ├── pb_spec.sh │ │ ├── ts_spec.sh │ │ └── cs_spec.sh │ ├── run-publish-scala.sh │ └── run-flake-refresh.sh ├── mods │ └── flake-refresh.sh ├── env.sh └── flows │ └── do-build.sh ├── project ├── build.properties ├── project │ ├── PluginVersions.sc │ └── PluginVersions.scala ├── Settings.scala ├── scalaxmlExclusion.sbt ├── Versions.scala └── plugins.sbt ├── version.sbt ├── idealingua-v1 ├── idealingua-v1-compiler │ └── src │ │ ├── test │ │ └── scala │ │ │ └── izumi │ │ │ └── .keep │ │ └── main │ │ └── scala │ │ └── izumi │ │ └── idealingua │ │ └── compiler │ │ ├── Shutdown.scala │ │ ├── CompilerLog.scala │ │ └── ShutdownImpl.scala ├── idealingua-v1-runtime-rpc-go │ └── src │ │ └── main │ │ └── resources │ │ └── runtime │ │ └── go │ │ └── irt │ │ ├── transport_http_server.go │ │ └── marshaller.go ├── idealingua-v1-test-defs │ └── src │ │ └── main │ │ ├── resources │ │ ├── defs │ │ │ ├── main-tests │ │ │ │ └── source │ │ │ │ │ ├── overlaytest │ │ │ │ │ ├── withoverlay.model │ │ │ │ │ ├── withoverlay.domain.overlay │ │ │ │ │ ├── withoverlay.model.overlay │ │ │ │ │ └── withoverlay.domain │ │ │ │ │ ├── model01.model │ │ │ │ │ ├── izumi │ │ │ │ │ └── test │ │ │ │ │ │ ├── model03shared02.model │ │ │ │ │ │ ├── model03shared01.model │ │ │ │ │ │ ├── model02.model │ │ │ │ │ │ ├── clashing │ │ │ │ │ │ └── another.domain │ │ │ │ │ │ ├── model03.model │ │ │ │ │ │ ├── clashing.domain │ │ │ │ │ │ └── domain03recursive01.domain │ │ │ │ │ └── idltest │ │ │ │ │ ├── aliases2.domain │ │ │ │ │ ├── clones.domain │ │ │ │ │ ├── aliases.domain │ │ │ │ │ ├── upcasts.domain │ │ │ │ │ ├── streams.domain │ │ │ │ │ ├── enums.domain │ │ │ │ │ ├── datainheritancetransitive.domain │ │ │ │ │ ├── jsonlike.domain │ │ │ │ │ ├── syntax.domain │ │ │ │ │ ├── phase.domain │ │ │ │ │ ├── datainheritance.domain │ │ │ │ │ ├── diamonds.domain │ │ │ │ │ ├── buzzers.domain │ │ │ │ │ ├── substraction.domain │ │ │ │ │ ├── identifiers.domain │ │ │ │ │ ├── dtofields.domain │ │ │ │ │ ├── algebraics.domain │ │ │ │ │ └── anyvals.domain │ │ │ ├── overlays │ │ │ │ ├── source │ │ │ │ │ └── com │ │ │ │ │ │ └── mycompany │ │ │ │ │ │ ├── email.model │ │ │ │ │ │ └── example.domain │ │ │ │ └── overlay │ │ │ │ │ ├── example.model.overlay │ │ │ │ │ └── example.domain.overlay │ │ │ └── subdir │ │ │ │ └── source │ │ │ │ └── test │ │ │ │ └── domain01.domain │ │ ├── refs │ │ │ └── csharp │ │ │ │ ├── UnityEngine.dll │ │ │ │ ├── Newtonsoft.Json.dll │ │ │ │ ├── nunit.framework.dll │ │ │ │ ├── websocket-sharp.dll │ │ │ │ └── UnityEngine.Networking.dll │ │ └── defs-special │ │ │ └── scala-only │ │ │ └── source │ │ │ └── idltest │ │ │ ├── crossimports3.domain │ │ │ ├── crossimports2.domain │ │ │ └── crossimports1.domain │ │ └── scala │ │ └── izumi │ │ └── r2 │ │ └── idealingua │ │ └── test │ │ ├── impls │ │ └── AbstractGreeterServer.scala │ │ └── GreeterRunnerExample.scala ├── idealingua-v1-runtime-rpc-csharp │ └── src │ │ └── main │ │ ├── nuget │ │ ├── solution │ │ │ └── Izumi.RPC.Runtime.CS.IRT │ │ │ │ ├── README.md │ │ │ │ └── IRT │ │ └── publish.sh │ │ └── resources │ │ ├── runtime │ │ └── csharp │ │ │ └── IRT │ │ │ ├── Void.cs │ │ │ ├── Transport │ │ │ ├── Client │ │ │ │ ├── IClientTransportCallback.cs │ │ │ │ ├── IClientTransportContext.cs │ │ │ │ ├── WebSocketTransport.cs │ │ │ │ ├── SyncHttpTransport.cs │ │ │ │ ├── AsyncHttpTransport.cs │ │ │ │ └── IClientTranport.cs │ │ │ ├── Server │ │ │ │ ├── ConnectionContext.cs │ │ │ │ ├── WebSocketServer.cs │ │ │ │ └── SystemContext.cs │ │ │ ├── Authorization │ │ │ │ ├── AuthMethod.cs │ │ │ │ ├── AuthToken.cs │ │ │ │ ├── AuthCustom.cs │ │ │ │ ├── AuthBasic.cs │ │ │ │ └── AuthApiKey.cs │ │ │ ├── WebSocketMessageType.cs │ │ │ └── WebSocketMessageBase.cs │ │ │ ├── RTTI.cs │ │ │ ├── Logger │ │ │ ├── DummyLogger.cs │ │ │ ├── TransportLogger.cs │ │ │ └── ConsoleLogger.cs │ │ │ ├── ILogger.cs │ │ │ ├── IServiceDispatcher.cs │ │ │ ├── Marshaller │ │ │ └── Marshaller.cs │ │ │ ├── UrlEscaper.cs │ │ │ ├── DispatcherException.cs │ │ │ └── Dispatcher.cs │ │ └── unicorn.png ├── idealingua-v1-runtime-rpc-typescript │ └── src │ │ ├── main │ │ └── resources │ │ │ └── runtime │ │ │ └── typescript │ │ │ └── irt │ │ │ ├── void.ts │ │ │ ├── logger │ │ │ ├── index.ts │ │ │ ├── logger.dummy.ts │ │ │ └── logger.ts │ │ │ ├── transport │ │ │ ├── client │ │ │ │ └── index.ts │ │ │ ├── auth │ │ │ │ ├── auth.method.ts │ │ │ │ ├── index.ts │ │ │ │ ├── auth.custom.ts │ │ │ │ ├── auth.token.ts │ │ │ │ ├── auth.apikey.ts │ │ │ │ └── auth.basic.ts │ │ │ ├── index.ts │ │ │ ├── server │ │ │ │ ├── index.ts │ │ │ │ ├── transport.context.system.ts │ │ │ │ ├── transport.context.ts │ │ │ │ └── transport.server.ts │ │ │ ├── transport.ts │ │ │ └── transport.websocket.ts │ │ │ ├── index.ts │ │ │ └── dispatcher.ts │ │ └── npmjs │ │ ├── tsconfig.es.json │ │ ├── package.json │ │ ├── tsconfig.json │ │ └── publish.sh ├── idealingua-v1-core │ ├── src │ │ └── main │ │ │ └── scala │ │ │ └── izumi │ │ │ └── idealingua │ │ │ ├── model │ │ │ ├── publishing │ │ │ │ ├── Publisher.scala │ │ │ │ └── manifests │ │ │ │ │ └── ProtobufBuildManifest.scala │ │ │ ├── output │ │ │ │ ├── Module.scala │ │ │ │ └── ModuleId.scala │ │ │ └── JavaType.scala │ │ │ └── il │ │ │ ├── renderer │ │ │ ├── package.scala │ │ │ ├── RDomainId.scala │ │ │ ├── IDLRenderer.scala │ │ │ ├── RField.scala │ │ │ ├── RIdField.scala │ │ │ ├── RStreamDirection.scala │ │ │ ├── RSimpleStructure.scala │ │ │ ├── RTypedStream.scala │ │ │ ├── RAdtMember.scala │ │ │ ├── RBuzzer.scala │ │ │ ├── RAnno.scala │ │ │ ├── RService.scala │ │ │ ├── RStreams.scala │ │ │ ├── MetaRenderer.scala │ │ │ ├── RStructure.scala │ │ │ └── RTypeId.scala │ │ │ ├── loader │ │ │ ├── ModelLoader.scala │ │ │ ├── ModelParser.scala │ │ │ ├── verification │ │ │ │ ├── GlobalVerificationRule.scala │ │ │ │ └── DuplicateDomainsRule.scala │ │ │ ├── ModelLoaderContext.scala │ │ │ ├── ExternalRefResolver.scala │ │ │ ├── FilesystemEnumerator.scala │ │ │ ├── ModelLoaderContextImpl.scala │ │ │ ├── ModelLoaderImpl.scala │ │ │ ├── DomainMeshResolvedMutable.scala │ │ │ └── ModelParserImpl.scala │ │ │ └── parser │ │ │ ├── structure │ │ │ ├── Symbols.scala │ │ │ ├── package.scala │ │ │ ├── Aggregates.scala │ │ │ ├── Comments.scala │ │ │ ├── Separators.scala │ │ │ └── MetaAggregates.scala │ │ │ ├── DefPositions.scala │ │ │ ├── DefBuzzer.scala │ │ │ ├── DefService.scala │ │ │ ├── DefParsers.scala │ │ │ ├── DefDomain.scala │ │ │ └── DefStreams.scala │ └── .jvm │ │ └── src │ │ └── main │ │ └── scala │ │ └── izumi │ │ └── idealingua │ │ └── il │ │ └── loader │ │ └── LocalModelLoaderContext.scala ├── idealingua-v1-model │ ├── src │ │ └── main │ │ │ └── scala │ │ │ └── izumi │ │ │ └── idealingua │ │ │ ├── runtime │ │ │ └── model │ │ │ │ ├── IDLAdt.scala │ │ │ │ ├── IDLEnum.scala │ │ │ │ ├── IDLGenerated.scala │ │ │ │ └── IDLIdentifier.scala │ │ │ └── model │ │ │ ├── common │ │ │ ├── package.scala │ │ │ ├── TrivialField.scala │ │ │ ├── SigParam.scala │ │ │ ├── StreamDirection.scala │ │ │ ├── TypePath.scala │ │ │ ├── DomainId.scala │ │ │ ├── PackageTools.scala │ │ │ └── ExtendedField.scala │ │ │ ├── il │ │ │ └── ast │ │ │ │ ├── raw │ │ │ │ ├── defns │ │ │ │ │ ├── RawSimpleStructure.scala │ │ │ │ │ ├── RawAnno.scala │ │ │ │ │ ├── RawBuzzer.scala │ │ │ │ │ ├── RawNodeMeta.scala │ │ │ │ │ ├── RawService.scala │ │ │ │ │ ├── RawStreams.scala │ │ │ │ │ ├── RawField.scala │ │ │ │ │ ├── RawStream.scala │ │ │ │ │ ├── defns.scala │ │ │ │ │ ├── RawAdt.scala │ │ │ │ │ ├── RawConstBlock.scala │ │ │ │ │ ├── RawTopLevelDefn.scala │ │ │ │ │ ├── RawMethod.scala │ │ │ │ │ ├── RawVal.scala │ │ │ │ │ └── RawEnumMember.scala │ │ │ │ ├── models │ │ │ │ │ ├── Inclusion.scala │ │ │ │ │ ├── ParsedModel.scala │ │ │ │ │ └── ModelMember.scala │ │ │ │ └── domains │ │ │ │ │ ├── Import.scala │ │ │ │ │ ├── ImportedId.scala │ │ │ │ │ ├── SingleImport.scala │ │ │ │ │ ├── ParsedDomain.scala │ │ │ │ │ ├── DomainHeader.scala │ │ │ │ │ ├── DomainMeshResolved.scala │ │ │ │ │ └── DomainMeshLoaded.scala │ │ │ │ ├── typed │ │ │ │ ├── Anno.scala │ │ │ │ ├── Service.scala │ │ │ │ ├── Streams.scala │ │ │ │ ├── Buzzer.scala │ │ │ │ ├── NodeMeta.scala │ │ │ │ ├── AdtMember.scala │ │ │ │ ├── TypedStream.scala │ │ │ │ ├── package.scala │ │ │ │ ├── ConstValue.scala │ │ │ │ ├── DefMethod.scala │ │ │ │ ├── DomainDefinition.scala │ │ │ │ └── TypeDef.scala │ │ │ │ └── InputPosition.scala │ │ │ ├── loader │ │ │ ├── UnresolvedDomains.scala │ │ │ ├── LoadedModel.scala │ │ │ ├── ModelParsingResult.scala │ │ │ └── DomainParsingResult.scala │ │ │ ├── typespace │ │ │ ├── verification │ │ │ │ ├── VerificationRule.scala │ │ │ │ ├── TypespaceVerifier.scala │ │ │ │ └── rules │ │ │ │ │ ├── AdtMembersRule.scala │ │ │ │ │ ├── BasicNamingConventionsRule.scala │ │ │ │ │ └── DuplicateMemberRule.scala │ │ │ └── structures │ │ │ │ ├── ConverterDef.scala │ │ │ │ ├── FieldConflicts.scala │ │ │ │ ├── ConstAbstractStruct.scala │ │ │ │ ├── AbstractStruct.scala │ │ │ │ └── Struct.scala │ │ │ └── problems │ │ │ ├── IDLException.scala │ │ │ └── IDLDiagnostics.scala │ ├── .js │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── izumi │ │ │ └── idealingua │ │ │ └── runtime │ │ │ └── model │ │ │ └── Escaping.scala │ └── .jvm │ │ └── src │ │ └── main │ │ └── scala │ │ └── izumi │ │ └── idealingua │ │ └── runtime │ │ └── model │ │ └── Escaping.scala ├── idealingua-v1-runtime-rpc-scala │ └── src │ │ └── main │ │ ├── scala │ │ └── izumi │ │ │ └── idealingua │ │ │ └── runtime │ │ │ ├── rpc │ │ │ ├── IRTWrappedClient.scala │ │ │ ├── IRTDispatcher.scala │ │ │ ├── IRTMethodSignature.scala │ │ │ ├── IRTServerMiddleware.scala │ │ │ ├── IRTWrappedService.scala │ │ │ ├── IRTCirceMarshaller.scala │ │ │ ├── IRTOutputMiddleware.scala │ │ │ ├── IRTMethodWrapper.scala │ │ │ ├── models.scala │ │ │ └── IRTTransportException.scala │ │ │ └── IRTCast.scala │ │ └── scala-3 │ │ └── IRTWithCirce.scala ├── idealingua-v1-transpilers │ └── src │ │ └── main │ │ └── scala │ │ └── izumi │ │ └── idealingua │ │ └── translator │ │ ├── toprotobuf │ │ ├── types │ │ │ ├── ProtobufField.scala │ │ │ ├── ProtobufAdtMember.scala │ │ │ ├── ProtobufType.scala │ │ │ └── ProtobufMethod.scala │ │ ├── EnumRenderer.scala │ │ ├── products │ │ │ └── RenderableCogenProduct.scala │ │ ├── CompositeRenderer.scala │ │ ├── IdentifierRenderer.scala │ │ ├── InterfaceRenderer.scala │ │ ├── extensions │ │ │ └── ProtobufTranslatorExtensions.scala │ │ ├── AdtRenderer.scala │ │ ├── AliasRenderer.scala │ │ └── PBTContext.scala │ │ ├── toscala │ │ ├── types │ │ │ ├── StructContext.scala │ │ │ ├── FullServiceContext.scala │ │ │ ├── ClassSource.scala │ │ │ ├── ScalaStruct.scala │ │ │ ├── ScalaType.scala │ │ │ ├── ScalaField.scala │ │ │ └── runtime │ │ │ │ ├── Pkg.scala │ │ │ │ └── Import.scala │ │ ├── layout │ │ │ ├── Scope.scala │ │ │ ├── SbtDslOp.scala │ │ │ └── ScalaNamingConvention.scala │ │ └── extensions │ │ │ └── ScalaTranslatorExtensions.scala │ │ ├── tocsharp │ │ ├── CSharpTranslationTools.scala │ │ ├── products │ │ │ └── RenderableCogenProduct.scala │ │ └── CSTContext.scala │ │ ├── togolang │ │ ├── GoLangTranslationTools.scala │ │ ├── extensions │ │ │ ├── GoLangTranslatorExtensions.scala │ │ │ └── GoLangTranslatorExtension.scala │ │ ├── products │ │ │ └── RenderableCogenProduct.scala │ │ ├── GLTContext.scala │ │ └── types │ │ │ └── GoLangImportRecord.scala │ │ ├── totypescript │ │ ├── TypeScriptTranslationTools.scala │ │ ├── products │ │ │ └── RenderableCogenProduct.scala │ │ ├── extensions │ │ │ ├── TypeScriptTranslatorExtensions.scala │ │ │ └── EnumHelpersExtension.scala │ │ ├── TSTContext.scala │ │ └── layout │ │ │ └── TypescriptNamingConvention.scala │ │ ├── Translator.scala │ │ ├── TranslatorExtension.scala │ │ ├── TranslatorDescriptor.scala │ │ └── IDLLanguage.scala └── idealingua-v1-runtime-rpc-http4s │ └── src │ ├── main │ └── scala │ │ └── izumi │ │ └── idealingua │ │ └── runtime │ │ └── rpc │ │ └── http4s │ │ ├── ws │ │ ├── WsSessionId.scala │ │ ├── RawResponse.scala │ │ └── WsSessionListener.scala │ │ ├── HttpExecutionContext.scala │ │ ├── context │ │ ├── WsIdExtractor.scala │ │ └── HttpContextExtractor.scala │ │ ├── IRTHttpFailureException.scala │ │ └── IRTAuthenticator.scala │ └── test │ └── scala │ └── izumi │ └── idealingua │ └── runtime │ └── rpc │ └── http4s │ └── fixtures │ ├── TestContext.scala │ └── LoggingWsListener.scala ├── secrets.tar.enc ├── devops └── release.sh ├── sbtgen.sc ├── .jvmopts ├── .scala-steward.conf └── LICENSE /.shellspec: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.envrc: -------------------------------------------------------------------------------- 1 | use_flake 2 | -------------------------------------------------------------------------------- /.mobala/version.txt: -------------------------------------------------------------------------------- 1 | develop -------------------------------------------------------------------------------- /project/build.properties: -------------------------------------------------------------------------------- 1 | sbt.version = 1.11.2 2 | -------------------------------------------------------------------------------- /project/project/PluginVersions.sc: -------------------------------------------------------------------------------- 1 | PluginVersions.scala -------------------------------------------------------------------------------- /version.sbt: -------------------------------------------------------------------------------- 1 | ThisBuild / version := "1.4.8-SNAPSHOT" 2 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-compiler/src/test/scala/izumi/.keep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.mobala/version-commit.lock: -------------------------------------------------------------------------------- 1 | 87a6a202f917745e826d6f245f78db48cb92965b -------------------------------------------------------------------------------- /.mobala/keep.env: -------------------------------------------------------------------------------- 1 | SONATYPE_SECRET 2 | SCALA_VERSION 3 | TOKEN_NUGET 4 | TOKEN_NPM -------------------------------------------------------------------------------- /secrets.tar.enc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7mind/idealingua-v1/HEAD/secrets.tar.enc -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-go/src/main/resources/runtime/go/irt/transport_http_server.go: -------------------------------------------------------------------------------- 1 | package irt -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/overlaytest/withoverlay.model: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/model01.model: -------------------------------------------------------------------------------- 1 | alias UserId = str 2 | -------------------------------------------------------------------------------- /project/Settings.scala: -------------------------------------------------------------------------------- 1 | import sbt.settingKey 2 | 3 | object DocKeys { 4 | lazy val prefix = settingKey[String]("") 5 | } 6 | -------------------------------------------------------------------------------- /.mobala/steps/run-gen.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -euo pipefail 4 | 5 | function run-gen() { 6 | bash sbtgen.sc --js 7 | } -------------------------------------------------------------------------------- /devops/release.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -xe 4 | 5 | ./sbtgen.sc 6 | 7 | git add . || true 8 | 9 | sbt "++2.13" "release" -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/nuget/solution/Izumi.RPC.Runtime.CS.IRT/README.md: -------------------------------------------------------------------------------- 1 | Idealingua v1 C# runtime -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/nuget/solution/Izumi.RPC.Runtime.CS.IRT/IRT: -------------------------------------------------------------------------------- 1 | ../../../resources/runtime/csharp/IRT/ -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/izumi/test/model03shared02.model: -------------------------------------------------------------------------------- 1 | 2 | alias Test2 = str 3 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/overlays/source/com/mycompany/email.model: -------------------------------------------------------------------------------- 1 | data Email { 2 | _: str 3 | } 4 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/izumi/test/model03shared01.model: -------------------------------------------------------------------------------- 1 | 2 | alias Test1 = str 3 | 4 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/izumi/test/model02.model: -------------------------------------------------------------------------------- 1 | enum AnEnum { 2 | VALUE1 3 | VALUE2 4 | } 5 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Void.cs: -------------------------------------------------------------------------------- 1 | 2 | namespace IRT { 3 | public sealed class Void { 4 | } 5 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/aliases2.domain: -------------------------------------------------------------------------------- 1 | domain idltest.aliases2 2 | 3 | mixin M2 { 4 | f2: str 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/overlays/overlay/example.model.overlay: -------------------------------------------------------------------------------- 1 | data ExtendedEmail { 2 | address : str 3 | verified : bit 4 | } 5 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/overlaytest/withoverlay.domain.overlay: -------------------------------------------------------------------------------- 1 | data OverlayEmailAttributes { 2 | disposable: bit 3 | } 4 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/void.ts: -------------------------------------------------------------------------------- 1 | 2 | export class Void { 3 | public static readonly instance = new Void(); 4 | } 5 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/izumi/test/clashing/another.domain: -------------------------------------------------------------------------------- 1 | domain izumi.test.clashing.another 2 | 3 | enum SomeEnum { 4 | VALUE 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/overlays/overlay/example.domain.overlay: -------------------------------------------------------------------------------- 1 | data ExtendedUser { 2 | name : str 3 | email : Email 4 | tags : set[str] 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-compiler/src/main/scala/izumi/idealingua/compiler/Shutdown.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.compiler 2 | 3 | trait Shutdown { 4 | def shutdown(message: String): Nothing 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/model/publishing/Publisher.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.publishing 2 | 3 | final case class Publisher(name: String, id: String) 4 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/unicorn.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7mind/idealingua-v1/HEAD/idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/unicorn.png -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/logger/index.ts: -------------------------------------------------------------------------------- 1 | 2 | export * from './logger.console'; 3 | export * from './logger.dummy'; 4 | export * from './logger'; -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/runtime/model/IDLAdt.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.model 2 | 3 | trait IDLAdt extends IDLGenerated { 4 | type Element <: IDLAdtElement 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/UnityEngine.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7mind/idealingua-v1/HEAD/idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/UnityEngine.dll -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/common/package.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model 2 | 3 | package object common { 4 | type Package = Seq[String] 5 | type TypeName = String 6 | } 7 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/izumi/test/model03.model: -------------------------------------------------------------------------------- 1 | include "model03shared01.model" 2 | include "model03shared02.model" 3 | 4 | alias Test11 = Test1 5 | alias Test12 = Test2 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/overlays/source/com/mycompany/example.domain: -------------------------------------------------------------------------------- 1 | domain com.mycompany.example 2 | 3 | include "email.model" 4 | 5 | data User { 6 | name: str 7 | email: Email 8 | } 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/Newtonsoft.Json.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7mind/idealingua-v1/HEAD/idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/Newtonsoft.Json.dll -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/nunit.framework.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7mind/idealingua-v1/HEAD/idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/nunit.framework.dll -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/websocket-sharp.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7mind/idealingua-v1/HEAD/idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/websocket-sharp.dll -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/model/output/Module.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.output 2 | 3 | final case class Module(id: ModuleId, content: String, meta: Map[String, String] = Map.empty) 4 | -------------------------------------------------------------------------------- /.mobala/steps/run-test-pb.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -euo pipefail 3 | 4 | function run-test-pb() { 5 | shellspec --format documentation --jobs "${NUMCPU}" -o junit --reportdir ./target/spec-reports/pb ./.mobala/steps/spec/pb_spec.sh 6 | } -------------------------------------------------------------------------------- /.mobala/steps/run-test-ts.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -euo pipefail 3 | 4 | function run-test-ts() { 5 | shellspec --format documentation --jobs "${NUMCPU}" -o junit --reportdir ./target/spec-reports/ts ./.mobala/steps/spec/ts_spec.sh 6 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/common/TrivialField.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.common 2 | 3 | // TODO: do we need this? 4 | final case class TrivialField(typeId: Builtin, name: String) 5 | -------------------------------------------------------------------------------- /.mobala/steps/run-test-cs.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -euo pipefail 3 | 4 | function run-test-cs() { 5 | shellspec --format documentation --jobs "${NUMCPU}" -o junit --reportdir ./target/spec-reports/cs ./.mobala/steps/spec/cs_spec.sh 6 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/izumi/test/clashing.domain: -------------------------------------------------------------------------------- 1 | domain izumi.test.clashing 2 | 3 | import izumi.test.clashing.another 4 | 5 | alias Imported = izumi.test.clashing.another#SomeEnum 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/UnityEngine.Networking.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7mind/idealingua-v1/HEAD/idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp/UnityEngine.Networking.dll -------------------------------------------------------------------------------- /project/project/PluginVersions.scala: -------------------------------------------------------------------------------- 1 | object PV { 2 | val izumi = "1.2.19" 3 | val packager = "1.11.1" 4 | 5 | val sbt_scoverage = "2.3.1" 6 | val sbt_pgp = "2.3.1" 7 | 8 | val scala_js_version = "1.19.0" 9 | } 10 | -------------------------------------------------------------------------------- /sbtgen.sc: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | cs launch com.lihaoyi:ammonite_2.13.12:2.5.11 --fork -M ammonite.Main -- sbtgen.sc $* 3 | exit 4 | !# 5 | import $file.project.Deps, Deps._ 6 | 7 | @main 8 | def entrypoint(args: String*) = Idealingua.entrypoint(args) 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawSimpleStructure.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | final case class RawSimpleStructure(concepts: RawStructures, fields: RawTuple) 4 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/loader/UnresolvedDomains.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.loader 2 | 3 | case class UnresolvedDomains(domains: ParsedDomains, models: ParsedModels, overlays: ParsedModels) 4 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/IRTWrappedClient.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | trait IRTWrappedClient { 4 | def allCodecs: Map[IRTMethodId, IRTCirceMarshaller] 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/npmjs/tsconfig.es.json: -------------------------------------------------------------------------------- 1 | { 2 | "extends": "./tsconfig.json", 3 | "compilerOptions" : { 4 | "module" : "ESNext", 5 | "target" : "ESNext", 6 | "outDir" : "dist-es", 7 | }, 8 | } 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/izumi/test/domain03recursive01.domain: -------------------------------------------------------------------------------- 1 | domain izumi.test.domain03 2 | 3 | include "model03.model" 4 | 5 | alias Test111 = Test11 6 | alias Test121 = Test12 7 | 8 | 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/types/ProtobufField.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf.types 2 | 3 | final case class ProtobufField(name: String, tpe: ProtobufType) 4 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/types/StructContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.types 2 | 3 | final case class StructContext(source: ClassSource, struct: ScalaStruct) 4 | -------------------------------------------------------------------------------- /.jvmopts: -------------------------------------------------------------------------------- 1 | -Xmx4G 2 | -Xss2m 3 | -XX:ReservedCodeCacheSize=256m 4 | -XX:MaxMetaspaceSize=3G 5 | 6 | -XX:+OmitStackTraceInFastThrow 7 | -XX:SoftRefLRUPolicyMSPerMB=50 8 | -Dsun.io.useCanonCaches=false 9 | -server 10 | 11 | -XX:+UseG1GC 12 | 13 | -------------------------------------------------------------------------------- /.mobala/steps/run-test-scala.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -euo pipefail 3 | 4 | function run-test-scala() { 5 | shellspec --format documentation --jobs "${NUMCPU}" -o junit --reportdir ./target/spec-reports/scala ./.mobala/steps/spec/scala_spec.sh 6 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Client/IClientTransportCallback.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | 4 | namespace IRT.Transport.Client { 5 | public interface IClientTransportCallback { 6 | } 7 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Client/IClientTransportContext.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | 4 | namespace IRT.Transport.Client { 5 | public interface IClientTransportContext { 6 | } 7 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/clones.domain: -------------------------------------------------------------------------------- 1 | domain idltest.clones 2 | 3 | mixin M0 { 4 | _: str 5 | } 6 | 7 | clone M0 into M1 8 | 9 | clone M0 into M2 { 10 | _: i32 11 | } 12 | 13 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/overlaytest/withoverlay.model.overlay: -------------------------------------------------------------------------------- 1 | data OverlayUserAttributes { 2 | name: str 3 | surname: str 4 | } 5 | 6 | @annotated(path = "users/{id}") 7 | declared User 8 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/models/Inclusion.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.models 2 | 3 | final case class Inclusion(i: String) { 4 | override def toString: String = s"`$i`" 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/client/index.ts: -------------------------------------------------------------------------------- 1 | 2 | export * from './transport.http.client'; 3 | export * from './transport.websocket.client'; 4 | export * from './transport.hybrid.client'; -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/IRTDispatcher.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | trait IRTDispatcher[F[_, _]] { 4 | def dispatch(input: IRTMuxRequest): F[Throwable, IRTMuxResponse] 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/RTTI.cs: -------------------------------------------------------------------------------- 1 | 2 | namespace IRT { 3 | public interface IRTTI { 4 | string GetPackageName(); 5 | string GetClassName(); 6 | string GetFullClassName(); 7 | } 8 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/main/scala/izumi/idealingua/runtime/rpc/http4s/ws/WsSessionId.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s.ws 2 | 3 | import java.util.UUID 4 | 5 | final case class WsSessionId(sessionId: UUID) extends AnyVal 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/auth/auth.method.ts: -------------------------------------------------------------------------------- 1 | 2 | export abstract class AuthMethod { 3 | public abstract fromValue(value: string): Error; 4 | public abstract toValue(): string; 5 | } 6 | 7 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs-special/scala-only/source/idltest/crossimports3.domain: -------------------------------------------------------------------------------- 1 | @nonportable() 2 | domain idltest.crossimports3 3 | 4 | import idltest.crossimports1 5 | 6 | data Dummy3 { 7 | other: idltest.crossimports1#Dummy1 8 | } 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs-special/scala-only/source/idltest/crossimports2.domain: -------------------------------------------------------------------------------- 1 | @nonportable() 2 | domain idltest.crossimports2 3 | 4 | import idltest.crossimports3 5 | 6 | data Dummy2 { 7 | other: opt[idltest.crossimports3#Dummy3] 8 | } 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/types/FullServiceContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.types 2 | 3 | final case class FullServiceContext(service: ServiceContext, methods: List[ServiceMethodProduct]) 4 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/model/output/ModuleId.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.output 2 | 3 | final case class ModuleId(path: Seq[String], name: String) { 4 | override def toString: String = s"module:${path.mkString("/")}/$name" 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Server/ConnectionContext.cs: -------------------------------------------------------------------------------- 1 | 2 | namespace IRT.Transport.Server { 3 | public class ConnectionContext { 4 | public SystemContext System; 5 | public C User; 6 | } 7 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/IRTMethodSignature.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | trait IRTMethodSignature { 4 | type Input <: Product 5 | type Output <: Product 6 | 7 | def id: IRTMethodId 8 | } 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/domains/Import.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.domains 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | 5 | final case class Import(id: DomainId, identifiers: Set[ImportedId]) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/domains/ImportedId.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.domains 2 | 3 | final case class ImportedId(name: String, as: Option[String]) { 4 | def importedAs: String = as.getOrElse(name) 5 | } 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/domains/SingleImport.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.domains 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | 5 | final case class SingleImport(domain: DomainId, imported: ImportedId) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawAnno.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.il.ast.InputPosition 4 | 5 | case class RawAnno(name: String, values: RawVal.CMap, position: InputPosition) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/Anno.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.il.ast.InputPosition 4 | 5 | case class Anno(name: String, values: Map[String, ConstValue], position: InputPosition) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/Service.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.common.TypeId.ServiceId 4 | 5 | final case class Service(id: ServiceId, methods: List[DefMethod], meta: NodeMeta) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/Streams.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.common.TypeId.StreamsId 4 | 5 | final case class Streams(id: StreamsId, streams: List[TypedStream], meta: NodeMeta) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/index.ts: -------------------------------------------------------------------------------- 1 | 2 | export * from './client'; 3 | export * from './server'; 4 | export * from './transport.websocket'; 5 | export * from './wsclient'; 6 | export * from './transport'; 7 | export * from './auth'; -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawBuzzer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.TypeId.BuzzerId 4 | 5 | final case class RawBuzzer(id: BuzzerId, events: List[RawMethod], meta: RawNodeMeta) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/runtime/model/IDLEnum.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.model 2 | 3 | trait IDLEnum extends IDLGenerated { 4 | type Element <: IDLEnumElement 5 | 6 | def all: Seq[Element] 7 | 8 | def parse(value: String): Element 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/main/scala/izumi/idealingua/runtime/rpc/http4s/HttpExecutionContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s 2 | 3 | import scala.concurrent.ExecutionContext 4 | 5 | final case class HttpExecutionContext(clientExecutionContext: ExecutionContext) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawNodeMeta.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.il.ast.InputPosition 4 | 5 | case class RawNodeMeta(doc: Option[String], annos: Seq[RawAnno], position: InputPosition) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawService.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.TypeId.ServiceId 4 | 5 | final case class RawService(id: ServiceId, methods: List[RawMethod], meta: RawNodeMeta) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawStreams.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.TypeId.StreamsId 4 | 5 | final case class RawStreams(id: StreamsId, streams: List[RawStream], meta: RawNodeMeta) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/auth/index.ts: -------------------------------------------------------------------------------- 1 | 2 | export * from './auth'; 3 | export * from './auth.method'; 4 | export * from './auth.apikey'; 5 | export * from './auth.basic'; 6 | export * from './auth.token'; 7 | export * from './auth.custom'; -------------------------------------------------------------------------------- /.mobala/mods/flake-refresh.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -euo pipefail 4 | 5 | step_enable run-flake-refresh 6 | 7 | export DO_FLAKE_VALIDATE=0 8 | 9 | for arg in "$@" ; do case $arg in 10 | --validate) 11 | export DO_FLAKE_VALIDATE=1 12 | ;; 13 | *) 14 | ;; 15 | esac done -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/common/SigParam.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.common 2 | 3 | case class SigParamSource(sourceType: TypeId, sourceName: String) 4 | 5 | case class SigParam(targetFieldName: String, source: SigParamSource, sourceFieldName: Option[String]) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/common/StreamDirection.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.common 2 | 3 | sealed trait StreamDirection 4 | 5 | object StreamDirection { 6 | case object ToServer extends StreamDirection 7 | case object ToClient extends StreamDirection 8 | } 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/logger/logger.dummy.ts: -------------------------------------------------------------------------------- 1 | import { Logger, LogLevel } from './logger'; 2 | 3 | export class DummyLogger implements Logger { 4 | public logf(level: LogLevel, ...args: any[]) { 5 | // Do nothing here... 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs-special/scala-only/source/idltest/crossimports1.domain: -------------------------------------------------------------------------------- 1 | @nonportable() 2 | domain idltest.crossimports1 3 | 4 | import idltest.crossimports2 5 | import idltest.crossimports3 6 | 7 | data Dummy1 { 8 | other: idltest.crossimports2#Dummy2 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawField.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.AbstractIndefiniteId 4 | 5 | final case class RawField(typeId: AbstractIndefiniteId, name: Option[String], meta: RawNodeMeta) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/logger/logger.ts: -------------------------------------------------------------------------------- 1 | 2 | export enum LogLevel { 3 | Trace, 4 | Debug, 5 | Info, 6 | Warning, 7 | Error 8 | } 9 | 10 | export interface Logger { 11 | logf(level: LogLevel, ...args: any[]): void 12 | } 13 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/aliases.domain: -------------------------------------------------------------------------------- 1 | domain idltest.aliases 2 | 3 | import idltest.aliases2 4 | 5 | mixin M1 { 6 | _: str 7 | } 8 | 9 | alias A1 = M1 10 | 11 | alias A2 = idltest.aliases2#M2 12 | 13 | data D1 { 14 | & A1 15 | & A2 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/domains/ParsedDomain.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.domains 2 | 3 | import izumi.idealingua.model.il.ast.raw.models.ParsedModel 4 | 5 | final case class ParsedDomain( 6 | decls: DomainHeader, 7 | model: ParsedModel, 8 | ) 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/models/ParsedModel.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.models 2 | 3 | import izumi.idealingua.model.il.ast.raw.defns.RawTopLevelDefn 4 | 5 | final case class ParsedModel(definitions: Seq[RawTopLevelDefn], includes: Seq[Inclusion]) 6 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Authorization/AuthMethod.cs: -------------------------------------------------------------------------------- 1 | 2 | namespace IRT.Transport.Authorization { 3 | public abstract class AuthMethod { 4 | public abstract bool FromValue(string value); 5 | public abstract string ToValue(); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/upcasts.domain: -------------------------------------------------------------------------------- 1 | domain idltest.upcasts 2 | 3 | mixin Identifiable { 4 | id: uid 5 | } 6 | 7 | mixin ItemContent { 8 | + Identifiable 9 | name: str 10 | } 11 | 12 | data Item { 13 | + ItemContent 14 | price: i32 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/server/index.ts: -------------------------------------------------------------------------------- 1 | 2 | export * from './transport.context'; 3 | export * from './transport.context.system'; 4 | export * from './transport.server.http'; 5 | export * from './transport.server.websocket'; 6 | export * from './transport.server'; -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Logger/DummyLogger.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | using IRT; 4 | 5 | namespace IRT.Logger { 6 | public class DummyLogger: ILogger { 7 | public void Logf(LogLevel level, string format, params object[] args) { 8 | } 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /.mobala/steps/run-publish-nuget.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | 4 | set -euo pipefail 5 | 6 | function run-publish-nuget() { 7 | validate_publishing || exit 0 8 | 9 | [[ -z "$TOKEN_NUGET" ]] && echo "Missing TOKEN_NUGET" && exit 0 10 | 11 | ./idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/nuget/publish.sh || exit 1 12 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/package.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il 2 | 3 | import izumi.functional.Renderable 4 | 5 | package object renderer { 6 | implicit class StaticRenderer[T](value: T) { 7 | def render()(implicit ev: Renderable[T]): String = ev.render(value) 8 | } 9 | 10 | } 11 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/server/transport.context.system.ts: -------------------------------------------------------------------------------- 1 | 2 | import { Authorization } from '../auth'; 3 | 4 | export class SystemContext { 5 | public auth: Authorization; 6 | 7 | constructor() { 8 | this.auth = new Authorization(); 9 | } 10 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/ModelLoader.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | import izumi.idealingua.model.loader.UnresolvedDomains 4 | 5 | trait ModelLoader { 6 | def load(): UnresolvedDomains 7 | } 8 | 9 | object ModelLoader { 10 | final val overlayVirtualDir = "[overlays]" 11 | } 12 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/runtime/model/IDLGenerated.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.model 2 | 3 | trait IDLGenerated extends Any 4 | 5 | trait IDLGeneratedType extends Any with IDLGenerated 6 | 7 | trait IDLEnumElement extends IDLGeneratedType 8 | 9 | trait IDLAdtElement extends IDLGeneratedType 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-compiler/src/main/scala/izumi/idealingua/compiler/CompilerLog.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.compiler 2 | 3 | trait CompilerLog { 4 | def log(s: String): Unit 5 | } 6 | 7 | object CompilerLog { 8 | 9 | object Default extends CompilerLog { 10 | override def log(s: String): Unit = println(s) 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /.mobala/steps/run-coverage.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -euo pipefail 4 | 5 | function run-coverage() { 6 | sbt -batch -no-colors -v \ 7 | --java-home "$JAVA_HOME" \ 8 | "$VERSION_COMMAND clean" \ 9 | coverage \ 10 | "$VERSION_COMMAND Test/compile" \ 11 | "$VERSION_COMMAND test" \ 12 | "$VERSION_COMMAND coverageReport" 13 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/domains/DomainHeader.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.domains 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | import izumi.idealingua.model.il.ast.raw.defns.RawNodeMeta 5 | 6 | final case class DomainHeader(id: DomainId, imports: Seq[Import], meta: RawNodeMeta) 7 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/tocsharp/CSharpTranslationTools.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.tocsharp 2 | 3 | import izumi.idealingua.model.common.TypeId 4 | 5 | import scala.meta._ 6 | 7 | class CSharpTranslationTools() { 8 | def idToParaName(id: TypeId) = Term.Name(id.name.toLowerCase) 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/togolang/GoLangTranslationTools.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.togolang 2 | 3 | import izumi.idealingua.model.common.TypeId 4 | 5 | import scala.meta._ 6 | 7 | class GoLangTranslationTools() { 8 | def idToParaName(id: TypeId) = Term.Name(id.name.toLowerCase) 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/verification/VerificationRule.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.verification 2 | 3 | import izumi.idealingua.model.problems.IDLDiagnostics 4 | import izumi.idealingua.model.typespace.Typespace 5 | 6 | trait VerificationRule { 7 | def verify(ts: Typespace): IDLDiagnostics 8 | } 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/layout/Scope.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.layout 2 | 3 | sealed trait Scope 4 | 5 | object Scope { 6 | 7 | case object ThisBuild extends Scope 8 | 9 | case object Project extends Scope 10 | 11 | case class Custom(scope: String) extends Scope 12 | } 13 | -------------------------------------------------------------------------------- /project/scalaxmlExclusion.sbt: -------------------------------------------------------------------------------- 1 | 2 | // Ignore scala-xml version conflict between scoverage where `coursier` requires scala-xml v2 3 | // and scoverage requires scala-xml v1 on Scala 2.12, 4 | // introduced when updating scoverage to 2.0.7 https://github.com/7mind/idealingua-v1/pull/373/ 5 | libraryDependencySchemes += "org.scala-lang.modules" %% "scala-xml" % VersionScheme.Always 6 | -------------------------------------------------------------------------------- /.mobala/env.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -euo pipefail 4 | if [[ "${DO_VERBOSE}" == 1 ]] ; then set -x ; fi 5 | 6 | set_gh_env 7 | set_scala_sbtgen_variables 8 | set_jvm_options 9 | 10 | export NUMCPU="$(nproc)" 11 | 12 | debug_env 13 | 14 | # this script receives all the CLI args from the main script and may decide which flows should be enabled 15 | flow_enable do-build -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/Buzzer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.common.TypeId.{BuzzerId, ServiceId} 4 | 5 | final case class Buzzer(id: BuzzerId, events: List[DefMethod], meta: NodeMeta) { 6 | def asService = Service(ServiceId(id.domain, id.name), events, meta) 7 | } 8 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/totypescript/TypeScriptTranslationTools.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.totypescript 2 | 3 | import izumi.idealingua.model.common.TypeId 4 | 5 | import scala.meta._ 6 | 7 | class TypeScriptTranslationTools() { 8 | def idToParaName(id: TypeId) = Term.Name(id.name.toLowerCase) 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/ModelParser.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | import izumi.idealingua.model.loader.{FSPath, ParsedDomains, ParsedModels} 4 | 5 | trait ModelParser { 6 | def parseModels(files: Map[FSPath, String]): ParsedModels 7 | 8 | def parseDomains(files: Map[FSPath, String]): ParsedDomains 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/verification/GlobalVerificationRule.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader.verification 2 | 3 | import izumi.idealingua.model.loader.LoadedDomain 4 | import izumi.idealingua.model.problems.IDLDiagnostics 5 | 6 | trait GlobalVerificationRule { 7 | def check(successful: Seq[LoadedDomain.Success]): IDLDiagnostics 8 | } 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/structure/Symbols.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser.structure 2 | 3 | import fastparse._ 4 | import fastparse.NoWhitespace._ 5 | 6 | trait Symbols { 7 | def NLC[$: P]: P[Unit] = P("\r\n" | "\n" | "\r") 8 | def String[$: P]: P[String] = P("\"" ~ CharsWhile(c => c != '"').rep().! ~ "\"") 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RDomainId.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.common.DomainId 5 | 6 | object RDomainId extends Renderable[DomainId] { 7 | override def render(value: DomainId): String = { 8 | value.toPackage.mkString(".") 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/index.ts: -------------------------------------------------------------------------------- 1 | 2 | export * from './transport'; 3 | export * from './logger'; 4 | export * from './introspector'; 5 | export * from './formatter'; 6 | export * from './marshaller'; 7 | export * from './transport'; 8 | export * from './dispatcher'; 9 | export * from './void'; 10 | export * from './either'; -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/Translator.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator 2 | 3 | import izumi.idealingua.model.output.Module 4 | import izumi.idealingua.model.typespace.Typespace 5 | 6 | case class Translated(typespace: Typespace, modules: Seq[Module]) 7 | 8 | trait Translator { 9 | def translate(): Translated 10 | } 11 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/streams.domain: -------------------------------------------------------------------------------- 1 | domain idltest.streams 2 | 3 | data Nuthing {} 4 | 5 | // NOTE: It's just a syntax. Streams aren't supported by transpilers yet. https://github.com/7mind/izumi/issues/89 6 | streams TestStreams { 7 | toclient empty(firstName: str, secondName: str) 8 | toserver hello(name: str) 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/loader/LoadedModel.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.loader 2 | 3 | import izumi.idealingua.model.il.ast.raw.defns.RawTopLevelDefn 4 | 5 | final case class LoadedModel(definitions: Seq[RawTopLevelDefn]) { 6 | def ++(other: LoadedModel): LoadedModel = { 7 | LoadedModel(definitions ++ other.definitions) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/types/ProtobufAdtMember.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf.types 2 | 3 | import izumi.fundamentals.platform.strings.IzString._ 4 | 5 | final case class ProtobufAdtMember(memberName: Option[String], tpe: ProtobufType) { 6 | def name: String = memberName.getOrElse(tpe.name).uncapitalize 7 | } 8 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/NodeMeta.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.il.ast.InputPosition 4 | 5 | case class NodeMeta(doc: Option[String], annos: Seq[Anno], pos: InputPosition) 6 | 7 | object NodeMeta { 8 | final val empty: NodeMeta = NodeMeta(None, Seq.empty, InputPosition.Undefined) 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/structures/ConverterDef.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.structures 2 | 3 | import izumi.idealingua.model.common.{SigParam, SigParamSource, StructureId} 4 | 5 | final case class ConverterDef( 6 | typeToConstruct: StructureId, 7 | allFields: List[SigParam], 8 | outerParams: List[SigParamSource], 9 | ) 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/.js/src/main/scala/izumi/idealingua/runtime/model/Escaping.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.model 2 | 3 | import scala.scalajs.js.URIUtils 4 | 5 | object Escaping { 6 | // TODO: we may need to use a better escaping 7 | def escape(s: String): String = URIUtils.encodeURIComponent(s) 8 | 9 | def unescape(s: String): String = URIUtils.encodeURIComponent(s) 10 | } 11 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/ILogger.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | 4 | namespace IRT { 5 | public enum LogLevel { 6 | Trace, 7 | Debug, 8 | Info, 9 | Warning, 10 | Error 11 | } 12 | 13 | public interface ILogger { 14 | void Logf(LogLevel level, string format, params object[] args); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/subdir/source/test/domain01.domain: -------------------------------------------------------------------------------- 1 | domain izumi.test.domain01 2 | 3 | data NestedGenerics { 4 | nested: list[list[str]] 5 | } 6 | 7 | data NestedGenerics2 { 8 | nested: opt[list[str]] 9 | } 10 | 11 | enum GoAliasEnumTest { 12 | Val1 13 | Val2 14 | } 15 | 16 | 17 | mixin AllTypes { 18 | enumMap : map[GoAliasEnumTest, str] 19 | } 20 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/.jvm/src/main/scala/izumi/idealingua/runtime/model/Escaping.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.model 2 | 3 | import java.net.{URLDecoder, URLEncoder} 4 | 5 | object Escaping { 6 | // TODO: we may need to use a better escaping 7 | def escape(s: String): String = URLEncoder.encode(s, "UTF-8") 8 | 9 | def unescape(s: String): String = URLDecoder.decode(s, "UTF-8") 10 | } 11 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/AdtMember.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.common.{TypeId, TypeName} 4 | 5 | final case class AdtMember(typeId: TypeId, memberName: Option[TypeName], meta: NodeMeta) { 6 | def wireId: TypeName = memberName.getOrElse(typeId.name) 7 | def typename: TypeName = wireId.capitalize 8 | } 9 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/TypedStream.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.common.StreamDirection 4 | 5 | sealed trait TypedStream 6 | 7 | object TypedStream { 8 | final case class Directed(name: String, direction: StreamDirection, signature: SimpleStructure, meta: NodeMeta) extends TypedStream 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawStream.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.StreamDirection 4 | 5 | sealed trait RawStream 6 | 7 | object RawStream { 8 | final case class Directed(name: String, direction: StreamDirection, signature: RawSimpleStructure, meta: RawNodeMeta) extends RawStream 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/IRTServerMiddleware.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | import io.circe.Json 4 | 5 | trait IRTServerMiddleware[F[_, _], C] { 6 | def priority: Int 7 | def apply( 8 | methodId: IRTMethodId 9 | )(context: C, 10 | parsedBody: Json, 11 | )(next: => F[Throwable, Json] 12 | ): F[Throwable, Json] 13 | } 14 | -------------------------------------------------------------------------------- /.mobala/steps/run-publish-npm.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | 4 | set -euo pipefail 5 | 6 | function run-publish-npm() { 7 | validate_publishing || exit 0 8 | 9 | [[ -z "$TOKEN_NPM" ]] && echo "Missing TOKEN_NPM" && exit 0 10 | 11 | echo "//registry.npmjs.org/:_authToken=${TOKEN_NPM}" > ~/.npmrc 12 | npm whoami 13 | 14 | ./idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/npmjs/publish.sh || exit 1 15 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/IServiceDispatcher.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | using System.Collections; 4 | using System.Collections.Generic; 5 | 6 | namespace IRT { 7 | public interface IServiceDispatcher { 8 | D Dispatch(C ctx, string method, D data); 9 | string GetSupportedService(); 10 | string[] GetSupportedMethods(); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Marshaller/Marshaller.cs: -------------------------------------------------------------------------------- 1 | 2 | namespace IRT.Marshaller { 3 | public interface IMarshaller { 4 | T Marshal(I data); 5 | O Unmarshal(T data); 6 | } 7 | 8 | public interface IJsonMarshaller: IMarshaller { 9 | } 10 | 11 | public interface IBinaryMarshaller: IMarshaller { 12 | } 13 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/enums.domain: -------------------------------------------------------------------------------- 1 | domain idltest.enums 2 | 3 | enum TestEnum { 4 | Element1 = 123 5 | Element2 = "xxx" 6 | Element3 = ([123, 456]) 7 | Element4 8 | } 9 | 10 | data KVEnumGeneric { 11 | test: map[str, TestEnum] 12 | } 13 | 14 | data EnumHolder { 15 | en: TestEnum 16 | } 17 | 18 | enum ShortSyntaxEnum = Element11 | Element22 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/problems/IDLException.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.problems 2 | 3 | import izumi.idealingua.model.common.TypeId 4 | 5 | class IDLException(message: String, cause: Option[Throwable] = None) extends RuntimeException(message, cause.orNull) 6 | 7 | final case class IDLCyclicInheritanceException(message: String, members: Set[TypeId]) extends IDLException(message) 8 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/TranslatorExtension.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator 2 | 3 | final case class ExtensionId(id: String) extends AnyVal { 4 | override def toString: String = id 5 | } 6 | 7 | trait TranslatorExtension { 8 | def id: ExtensionId = ExtensionId(getClass.getSimpleName.split('$').head) 9 | 10 | override def toString: String = id.id 11 | } 12 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/structure/package.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser 2 | 3 | package object structure { 4 | 5 | object aggregates extends Aggregates 6 | 7 | object comments extends Comments 8 | 9 | object ids extends Identifiers 10 | 11 | object kw extends Keywords 12 | 13 | object sep extends Separators 14 | 15 | object sym extends Symbols 16 | 17 | } 18 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/defns.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw 2 | 3 | import izumi.idealingua.model.common.IndefiniteMixin 4 | import izumi.idealingua.model.common.TypeId.InterfaceId 5 | 6 | package object defns { 7 | type RawInterfaces = List[InterfaceId] 8 | type RawStructures = List[IndefiniteMixin] 9 | type RawTuple = List[RawField] 10 | } 11 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-compiler/src/main/scala/izumi/idealingua/compiler/ShutdownImpl.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.compiler 2 | 3 | object ShutdownImpl extends Shutdown { 4 | private val log = CompilerLog.Default 5 | def shutdown(message: String): Nothing = { 6 | log.log(message) 7 | System.out.flush() 8 | System.err.flush() 9 | System.exit(1) 10 | throw new IllegalArgumentException(message) 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/server/transport.context.ts: -------------------------------------------------------------------------------- 1 | 2 | import { SystemContext } from './transport.context.system'; 3 | 4 | export class ConnectionContext { 5 | public system: SystemContext; 6 | public user: C; 7 | 8 | constructor(user: C = undefined) { 9 | this.system = new SystemContext(); 10 | this.user = user; 11 | } 12 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/models/ModelMember.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.models 2 | 3 | import izumi.idealingua.model.il.ast.raw.defns.RawTopLevelDefn 4 | 5 | sealed trait ModelMember 6 | 7 | object ModelMember { 8 | final case class MMTopLevelDefn(v: RawTopLevelDefn) extends ModelMember 9 | final case class MMInclusion(v: Inclusion) extends ModelMember 10 | 11 | } 12 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/package.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast 2 | 3 | import izumi.idealingua.model.common.StructureId 4 | import izumi.idealingua.model.common.TypeId.InterfaceId 5 | 6 | package object typed { 7 | type Interfaces = List[InterfaceId] 8 | type Structures = List[StructureId] 9 | type Tuple = List[Field] 10 | type IdTuple = List[IdField] 11 | } 12 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/ModelLoaderContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | protected[loader] trait BaseModelLoadContext { 4 | def domainExt: String 5 | def modelExt: String 6 | def overlayExt: String 7 | 8 | def parser: ModelParser 9 | def loader: ModelLoader 10 | } 11 | 12 | trait ModelLoaderContext extends BaseModelLoadContext { 13 | 14 | def enumerator: FilesystemEnumerator 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/datainheritancetransitive.domain: -------------------------------------------------------------------------------- 1 | domain idltest.datainheritancetransitive 2 | 3 | alias CouponID = str 4 | 5 | mixin CouponData { 6 | validFrom: opt[tsl] 7 | validTill: opt[tsl] 8 | code: str 9 | } 10 | 11 | data Coupon { 12 | id: CouponID 13 | + CouponData 14 | } 15 | 16 | data MassCoupon { 17 | + Coupon 18 | code: str 19 | limit: opt[i64] 20 | } 21 | -------------------------------------------------------------------------------- /.mobala/flows/do-build.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -euo pipefail 4 | 5 | function do-build() { 6 | step_run_cond run-gen 7 | step_run_cond run-flake-refresh 8 | step_run_cond run-coverage 9 | 10 | step_run_cond run-test-scala 11 | step_run_cond run-test-pb 12 | step_run_cond run-test-ts 13 | step_run_cond run-test-cs 14 | 15 | step_run_cond run-publish-scala 16 | step_run_cond run-publish-npm 17 | step_run_cond run-publish-nuget 18 | } 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/server/transport.server.ts: -------------------------------------------------------------------------------- 1 | 2 | import * as http from 'http'; 3 | import { ConnectionContext } from './transport.context'; 4 | 5 | export interface TransportHandlers { 6 | onConnect(context: ConnectionContext, request: http.IncomingMessage): boolean 7 | onAuth(context: ConnectionContext): boolean 8 | onDisconnect(context: ConnectionContext): void 9 | } 10 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Logger/TransportLogger.cs: -------------------------------------------------------------------------------- 1 | using System.Collections.Generic; 2 | 3 | namespace IRT 4 | { 5 | public interface ITransportLogger : ILogger 6 | { 7 | void LogRequest(string method, string url, string data, Dictionary headers); 8 | 9 | void LogResponse(string method, string url, string response, long resultCode, 10 | Dictionary headers); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Client/WebSocketTransport.cs: -------------------------------------------------------------------------------- 1 | 2 | using IRT.Marshaller; 3 | 4 | namespace IRT.Transport.Client { 5 | 6 | public class WebSocketTransport: WebSocketTransportGeneric { 7 | public WebSocketTransport(string endpoint, IJsonMarshaller marshaller, ILogger logger, int timeout = 60) : 8 | base(endpoint, marshaller, logger, timeout) { 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/UrlEscaper.cs: -------------------------------------------------------------------------------- 1 | using System.Web; 2 | 3 | namespace IRT.Transport 4 | { 5 | public static class UrlEscaper 6 | { 7 | public static string Escape(string source) 8 | { 9 | return HttpUtility.UrlEncode(source); 10 | } 11 | 12 | public static string UnEscape(string source) 13 | { 14 | return HttpUtility.UrlDecode(source); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/overlaytest/withoverlay.domain: -------------------------------------------------------------------------------- 1 | domain overlaytest.withoverlay 2 | 3 | include "withoverlay.model" 4 | 5 | declared OverlayUserAttributes // optional declaration for clarity 6 | 7 | declared OverlayEmailAttributes // optional declaration for clarity 8 | 9 | data User { 10 | id: uid 11 | attributes: OverlayUserAttributes 12 | } 13 | 14 | data Email { 15 | attributes: OverlayEmailAttributes 16 | } 17 | 18 | 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/IDLRenderer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.idealingua.model.il.ast.typed._ 4 | 5 | final case class IDLRenderingOptions(expandIncludes: Boolean) 6 | 7 | class IDLRenderer(defn: DomainDefinition, options: IDLRenderingOptions) { 8 | 9 | private val context = new IDLRenderingContext(defn, options) 10 | 11 | def render(): String = { 12 | import context._ 13 | defn.render() 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RField.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.il.ast.typed.Field 5 | 6 | class RField(context: IDLRenderingContext) extends Renderable[Field] { 7 | import context._ 8 | 9 | override def render(field: Field): String = { 10 | val repr = s"${field.name}: ${field.typeId.render()}" 11 | context.meta.withMeta(field.meta, repr) 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/common/TypePath.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.common 2 | 3 | final case class TypePath(domain: DomainId, within: Package) { 4 | def sub(v: TypeName) = TypePath(domain, within :+ v) 5 | 6 | def toPackage: Package = domain.toPackage ++ within 7 | 8 | override def toString: TypeName = { 9 | if (within.isEmpty) { 10 | s"$domain/" 11 | } else { 12 | s"$domain/${within.mkString("/")}" 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RIdField.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.il.ast.typed.IdField 5 | 6 | class RIdField(context: IDLRenderingContext) extends Renderable[IdField] { 7 | import context._ 8 | 9 | override def render(field: IdField): String = { 10 | val repr = s"${field.name}: ${field.typeId.render()}" 11 | context.meta.withMeta(field.meta, repr) 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/common/DomainId.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.common 2 | 3 | import izumi.idealingua.model.common 4 | 5 | final case class DomainId(pkg: common.Package, id: String) { 6 | override def toString: String = s"{${toPackage.mkString(".")}}" 7 | 8 | def toPackage: common.Package = pkg :+ id 9 | } 10 | 11 | object DomainId { 12 | final val Builtin = DomainId(Seq.empty, "/") 13 | final val Undefined = DomainId(Seq.empty, ".") 14 | } 15 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/npmjs/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "private": false, 3 | "name": "@izumi-framework/izumi-runtime-typescript", 4 | "version": "0.0.1-build.0", 5 | "description": "Preliminary Izumi TypeScript runtime", 6 | "author": "Izumi Framework contributors", 7 | "license": "MIT", 8 | "dependencies": { 9 | "moment": "^2.29.1", 10 | "websocket": "^1.0.32", 11 | "@types/node": "^22.7.6", 12 | "@types/websocket": "^1.0.1" 13 | }, 14 | "peerDependencies": {} 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/ExternalRefResolver.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | import izumi.idealingua.model.il.ast.raw.domains.DomainMeshResolved 4 | import izumi.idealingua.model.loader._ 5 | 6 | private[loader] class ExternalRefResolver(domains: UnresolvedDomains) { 7 | 8 | def resolveReferences(domain: DomainParsingResult): Either[LoadedDomain.Failure, DomainMeshResolved] = { 9 | new ExternalRefResolverPass(domains).resolveReferences(domain) 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /.mobala/steps/spec/pb_spec.sh: -------------------------------------------------------------------------------- 1 | Describe 'Protobuf transpiler' 2 | Include ./.mobala/steps/lib/builders.sh 3 | 4 | Parameters:dynamic 5 | %data ./idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests 6 | %data ./idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/overlays 7 | End 8 | 9 | It "builds Protobuf project in $1" 10 | When call test_pb_prj "$1" 11 | The status should be success 12 | The output should match pattern '*' 13 | The stderr should match pattern '*' 14 | End 15 | End 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RStreamDirection.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.common.StreamDirection 5 | 6 | object RStreamDirection extends Renderable[StreamDirection] { 7 | override def render(value: StreamDirection): String = { 8 | value match { 9 | case StreamDirection.ToServer => 10 | "toserver" 11 | case StreamDirection.ToClient => 12 | "toclient" 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/jsonlike.domain: -------------------------------------------------------------------------------- 1 | domain idltest.json 2 | 3 | adt JSONLike 4 | = JLObject 5 | | JLArray 6 | | JLString 7 | | JLNumber 8 | | JLBool 9 | | JLNull 10 | 11 | data JLNull {} 12 | 13 | data JLObject { 14 | fields: map[str, JSONLike] 15 | } 16 | 17 | data JLArray { 18 | values: list[JSONLike] 19 | } 20 | 21 | data JLString { 22 | value: str 23 | } 24 | 25 | data JLNumber { 26 | value: f64 27 | } 28 | 29 | data JLBool { 30 | value: bit 31 | } 32 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/syntax.domain: -------------------------------------------------------------------------------- 1 | // now we support comments at the beginning 2 | domain idltest.syntax 3 | 4 | mixin TestMixin { 5 | 6 | } 7 | 8 | data TestDto { 9 | _ : TestMixin 10 | } 11 | 12 | data TestDto1 { 13 | : TestMixin 14 | } 15 | 16 | id TestId { 17 | _ : str 18 | } 19 | 20 | id TestId1 { 21 | : str 22 | } 23 | 24 | 25 | 26 | data TestOneliners { _: TestDto, _: str, _: i08 } 27 | 28 | adt Ast 29 | = TestMixin 30 | | TestDto 31 | | TestOneliners 32 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/main/scala/izumi/idealingua/runtime/rpc/http4s/context/WsIdExtractor.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s.context 2 | 3 | trait WsIdExtractor[RequestCtx, WsCtx] { 4 | def extract(ctx: RequestCtx, previous: Option[WsCtx]): Option[WsCtx] 5 | } 6 | 7 | object WsIdExtractor { 8 | def id[C]: WsIdExtractor[C, C] = (c, _) => Some(c) 9 | def widen[C, C0 >: C]: WsIdExtractor[C, C0] = (c, _) => Some(c) 10 | def unit[C]: WsIdExtractor[C, Unit] = (_, _) => Some(()) 11 | } 12 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/DispatcherException.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | using System.Collections; 4 | using System.Collections.Generic; 5 | 6 | namespace IRT { 7 | public class DispatcherException: Exception { 8 | public DispatcherException() { 9 | } 10 | 11 | public DispatcherException(string message): base(message) { 12 | } 13 | 14 | public DispatcherException(string message, Exception inner): base(message, inner) { 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/EnumRenderer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf 2 | 3 | import izumi.idealingua.model.il.ast.typed.TypeDef.Enumeration 4 | import izumi.idealingua.translator.toprotobuf.products.CogenProducts 5 | 6 | final class EnumRenderer(ctx: PBTContext) { 7 | def defns(i: Enumeration): CogenProducts.Enum = { 8 | val self = ctx.conv.toProtobuf(i.id) 9 | ctx.ext.extend(i, CogenProducts.Enum(self, i.members.map(_.value)), _.handleEnum) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/DefPositions.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser 2 | 3 | import izumi.idealingua.model.il.ast.InputPosition 4 | import fastparse.NoWhitespace._ 5 | import fastparse._ 6 | 7 | class DefPositions(context: IDLParserContext) { 8 | def positioned[T](defparser: => P[T])(implicit v: P[?]): P[(InputPosition, T)] = { 9 | (Index ~ defparser ~ Index).map { 10 | case (start, value, stop) => 11 | (InputPosition.Defined(start, stop, context.file), value) 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/common/PackageTools.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.common 2 | 3 | object PackageTools { 4 | def minimize(value: Package, in: Package): Package = { 5 | 6 | val mapping = value 7 | .map(Option.apply) 8 | .zipAll(in.map(Option.apply), None, None) 9 | .map { 10 | case (l, r) => (l, r, l == r) 11 | } 12 | if (mapping.zip(in).forall(_._1._3)) { 13 | value.takeRight(value.size - in.size) 14 | } else { 15 | value 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Authorization/AuthToken.cs: -------------------------------------------------------------------------------- 1 | 2 | namespace IRT.Transport.Authorization { 3 | class AuthToken: AuthMethod { 4 | public string Token; 5 | 6 | public AuthToken(string token = null) { 7 | Token = token; 8 | } 9 | 10 | public override bool FromValue(string value) { 11 | return false; 12 | } 13 | 14 | public override string ToValue() { 15 | return "Bearer " + Token; 16 | } 17 | } 18 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/auth/auth.custom.ts: -------------------------------------------------------------------------------- 1 | import { AuthMethod } from './auth.method'; 2 | 3 | export class AuthCustom extends AuthMethod { 4 | public value: string; 5 | constructor(value: string) { 6 | super(); 7 | this.value = value; 8 | } 9 | 10 | public fromValue(value: string): Error { 11 | this.value = value; 12 | return undefined; 13 | } 14 | 15 | public toValue(): string { 16 | return this.value; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/loader/ModelParsingResult.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.loader 2 | 3 | import izumi.idealingua.model.il.ast.raw.models.ParsedModel 4 | 5 | sealed trait ModelParsingResult { 6 | def path: FSPath 7 | } 8 | 9 | object ModelParsingResult { 10 | final case class Success(path: FSPath, model: ParsedModel) extends ModelParsingResult 11 | final case class Failure(path: FSPath, message: String) extends ModelParsingResult 12 | } 13 | 14 | case class ParsedModels(results: Seq[ModelParsingResult]) 15 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/products/RenderableCogenProduct.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf.products 2 | 3 | trait RenderableCogenProduct { 4 | def preamble: List[String] 5 | def render: List[String] 6 | def isEmpty: Boolean = render.isEmpty 7 | } 8 | 9 | object RenderableCogenProduct { 10 | def empty: RenderableCogenProduct = new RenderableCogenProduct { 11 | override def render: List[String] = List.empty 12 | override def preamble: List[String] = Nil 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/phase.domain: -------------------------------------------------------------------------------- 1 | domain idltest.phase 2 | 3 | // abc 4 | 5 | mixin Name { 6 | name: str 7 | } 8 | 9 | mixin LengthInBytes { 10 | bytes: i64 11 | } 12 | 13 | // flow: incoming -> stored -> view 14 | 15 | data Name_incoming { 16 | & Name 17 | } 18 | 19 | mixin Name_stored_ { 20 | & Name 21 | + LengthInBytes 22 | } 23 | 24 | data Name_stored { 25 | & Name_stored_ 26 | } 27 | 28 | data Name_view { 29 | & Name 30 | + Name_stored_ 31 | relatives: list[Name] 32 | } 33 | 34 | 35 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/loader/DomainParsingResult.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.loader 2 | 3 | import izumi.idealingua.model.il.ast.raw.domains.ParsedDomain 4 | 5 | sealed trait DomainParsingResult { 6 | def path: FSPath 7 | } 8 | 9 | object DomainParsingResult { 10 | final case class Success(path: FSPath, domain: ParsedDomain) extends DomainParsingResult 11 | final case class Failure(path: FSPath, message: String) extends DomainParsingResult 12 | } 13 | 14 | case class ParsedDomains(results: Seq[DomainParsingResult]) 15 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Client/SyncHttpTransport.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | using System.IO; 4 | using System.Net; 5 | using System.Text; 6 | using System.Collections.Specialized; 7 | using IRT.Marshaller; 8 | 9 | namespace IRT.Transport.Client { 10 | public class SyncHttpTransport: SyncHttpTransportGeneric { 11 | public SyncHttpTransport(string endpoint, IJsonMarshaller marshaller, int timeout = 60): 12 | base(endpoint, marshaller, timeout) {} 13 | } 14 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Authorization/AuthCustom.cs: -------------------------------------------------------------------------------- 1 | 2 | namespace IRT.Transport.Authorization { 3 | class AuthCustom: AuthMethod { 4 | public string Value; 5 | 6 | public AuthCustom(string value = null) { 7 | Value = value; 8 | } 9 | 10 | public override bool FromValue(string value) { 11 | Value = value; 12 | return true; 13 | } 14 | 15 | public override string ToValue() { 16 | return Value; 17 | } 18 | } 19 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Client/AsyncHttpTransport.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | using System.IO; 4 | using System.Net; 5 | using System.Text; 6 | using System.Collections.Specialized; 7 | using IRT.Marshaller; 8 | 9 | namespace IRT.Transport.Client { 10 | public class AsyncHttpTransport: AsyncHttpTransportGeneric { 11 | public AsyncHttpTransport(string endpoint, IJsonMarshaller marshaller, int timeout = 60): 12 | base(endpoint, marshaller, timeout) {} 13 | } 14 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/CompositeRenderer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf 2 | 3 | import izumi.idealingua.model.il.ast.typed.TypeDef.DTO 4 | import izumi.idealingua.translator.toprotobuf.products.CogenProducts 5 | 6 | final class CompositeRenderer(ctx: PBTContext) { 7 | def defns(i: DTO): CogenProducts.Message = { 8 | val self = ctx.conv.toProtobuf(i.id) 9 | val fields = ctx.conv.toProtobuf(i.struct.fields) 10 | ctx.ext.extend(i, CogenProducts.Message(self, fields), _.handleDto) 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/FilesystemEnumerator.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | import izumi.idealingua.model.loader.FSPath 4 | 5 | trait FilesystemEnumerator { 6 | def enumerate(): Map[FSPath, String] 7 | } 8 | 9 | object FilesystemEnumerator { 10 | 11 | class Pseudo(files: Map[String, String]) extends FilesystemEnumerator { 12 | override def enumerate(): Map[FSPath, String] = { 13 | files.map { 14 | case (path, content) => 15 | FSPath.parse(path) -> content 16 | } 17 | } 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RSimpleStructure.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.il.ast.typed.SimpleStructure 5 | 6 | class RSimpleStructure(context: IDLRenderingContext) extends Renderable[SimpleStructure] { 7 | import context._ 8 | 9 | override def render(signature: SimpleStructure): String = { 10 | Seq( 11 | signature.concepts.map(_.render()).map(t => s"+ $t"), 12 | signature.fields.map(_.render()), 13 | ).flatten.mkString(", ") 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/IRTCast.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime 2 | 3 | trait IRTCast[From, To] { 4 | def convert(f: From): To 5 | } 6 | 7 | trait IRTExtend[From, To] { 8 | type INSTANTIATOR 9 | def next(f: From): INSTANTIATOR 10 | } 11 | 12 | trait IRTConversions[From] { 13 | protected def _value: From 14 | def to[T](implicit converter: IRTCast[From, T]): T = converter.convert(_value) 15 | def extend[T](implicit converter: IRTExtend[From, T]): converter.INSTANTIATOR = converter.next(_value) 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/datainheritance.domain: -------------------------------------------------------------------------------- 1 | domain idltest.datainheritance 2 | 3 | data TestData1 { 4 | _: str 5 | _: i32 6 | } 7 | 8 | data TestData2 { 9 | + TestData1 10 | _: i08 11 | } 12 | 13 | /* this example triggers a cornercase with converters 14 | that cornercase was triggered by workaround for scala erasure issue 15 | which was triggered by introduction of structural inheritance of dtos 16 | */ 17 | 18 | data ParameterDTO { 19 | _: i32 20 | _: str 21 | } 22 | 23 | data UserDTO { 24 | _: ParameterDTO 25 | } 26 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/main/scala/izumi/idealingua/runtime/rpc/http4s/ws/RawResponse.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s.ws 2 | 3 | import io.circe.Json 4 | import izumi.idealingua.runtime.rpc.* 5 | 6 | sealed trait RawResponse 7 | 8 | object RawResponse { 9 | final case class EmptyRawResponse() extends RawResponse 10 | final case class GoodRawResponse(data: Json, method: IRTMethodId) extends RawResponse 11 | final case class BadRawResponse(data: Option[Json]) extends RawResponse { 12 | def error: String = data.map(_.noSpaces).getOrElse("N/A") 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/IdentifierRenderer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf 2 | 3 | import izumi.idealingua.model.il.ast.typed.TypeDef.Identifier 4 | import izumi.idealingua.translator.toprotobuf.products.CogenProducts 5 | 6 | final class IdentifierRenderer(ctx: PBTContext) { 7 | def defns(i: Identifier): CogenProducts.Message = { 8 | val self = ctx.conv.toProtobuf(i.id) 9 | val fields = ctx.conv.toProtobuf(i.fields) 10 | ctx.ext.extend(i, CogenProducts.Message(self, fields), _.handleIdentifier) 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawAdt.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.{AbstractIndefiniteId, TypeName} 4 | 5 | final case class RawAdt(alternatives: List[RawAdt.Member]) 6 | 7 | object RawAdt { 8 | 9 | sealed trait Member 10 | 11 | object Member { 12 | 13 | final case class TypeRef(typeId: AbstractIndefiniteId, memberName: Option[TypeName], meta: RawNodeMeta) extends Member 14 | 15 | final case class NestedDefn(nested: RawTypeDef.WithId) extends Member 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/diamonds.domain: -------------------------------------------------------------------------------- 1 | domain idltest.diamonds 2 | 3 | mixin TestInterface1 { 4 | if1Field_overriden: i32 5 | if1Field_inherited: i32 6 | sameField: i64 7 | sameEverywhereField: i64 8 | } 9 | 10 | mixin TestInterface2 { 11 | if2Field: i64 12 | sameField: i64 13 | sameEverywhereField: i64 14 | } 15 | 16 | mixin TestInterface3 { 17 | + TestInterface1 18 | 19 | if1Field_overriden: i32 20 | if3Field: i64 21 | sameEverywhereField: i64 22 | } 23 | 24 | data DTO1 { 25 | + TestInterface2 26 | + TestInterface3 27 | } 28 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/InterfaceRenderer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf 2 | 3 | import izumi.idealingua.model.il.ast.typed.TypeDef.Interface 4 | import izumi.idealingua.translator.toprotobuf.products.CogenProducts 5 | 6 | final class InterfaceRenderer(ctx: PBTContext) { 7 | def defns(i: Interface): CogenProducts.Message = { 8 | val self = ctx.conv.toProtobuf(i.id) 9 | val fields = ctx.conv.toProtobuf(i.struct.fields) 10 | ctx.ext.extend(i, CogenProducts.Message(self, fields), _.handleInterface) 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RTypedStream.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.il.ast.typed.TypedStream 5 | 6 | class RTypedStream(context: IDLRenderingContext) extends Renderable[TypedStream] { 7 | import context._ 8 | 9 | override def render(ts: TypedStream): String = { 10 | ts match { 11 | case m: TypedStream.Directed => 12 | val out = s"${m.direction.render()} ${m.name}(${m.signature.render()})" 13 | context.meta.withMeta(m.meta, out) 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/InputPosition.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast 2 | 3 | import izumi.idealingua.model.loader.FSPath 4 | 5 | sealed trait InputPosition 6 | 7 | object InputPosition { 8 | 9 | case class Defined(start: Int, stop: Int, file: FSPath) extends InputPosition { 10 | // TODO: this is a very dirty solution for comparison problem in LoaderTest 11 | override def hashCode(): Int = 0 12 | 13 | override def equals(obj: Any): Boolean = obj.isInstanceOf[Defined] 14 | } 15 | 16 | case object Undefined extends InputPosition 17 | 18 | } 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawConstBlock.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.TypeId.ConstId 4 | import izumi.idealingua.model.il.ast.InputPosition 5 | 6 | final case class RawConstBlock(consts: List[RawConst]) 7 | 8 | final case class RawConstMeta(doc: Option[String], position: InputPosition) 9 | 10 | object RawConstMeta { 11 | def apply(position: InputPosition): RawConstMeta = new RawConstMeta(None, position) 12 | } 13 | 14 | final case class RawConst(id: ConstId, const: RawVal, meta: RawConstMeta) 15 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/types/ClassSource.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.types 2 | 3 | import izumi.idealingua.model.il.ast.typed.TypeDef._ 4 | 5 | sealed trait ClassSource 6 | 7 | object ClassSource { 8 | final case class CsDTO(dto: DTO) extends ClassSource 9 | final case class CsInterface(i: Interface) extends ClassSource 10 | final case class CsMethodInput(sc: ServiceContext, smp: ServiceMethodProduct) extends ClassSource 11 | final case class CsMethodOutput(sc: ServiceContext, smp: ServiceMethodProduct) extends ClassSource 12 | } 13 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/.jvm/src/main/scala/izumi/idealingua/il/loader/LocalModelLoaderContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | import java.io.File 4 | import java.nio.file.Path 5 | 6 | class LocalModelLoaderContext(src: Seq[Path], cp: Seq[File]) extends ModelLoaderContextImpl(LocalModelLoaderContext.makeEnumerator(src, cp)) 7 | 8 | object LocalModelLoaderContext { 9 | def makeEnumerator(src: Seq[Path], cp: Seq[File])(c: BaseModelLoadContext): LocalFilesystemEnumerator = { 10 | val allExts = Set(c.modelExt, c.domainExt, c.overlayExt) 11 | new LocalFilesystemEnumerator(src, cp, allExts) 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/ModelLoaderContextImpl.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | class ModelLoaderContextImpl(makeEnumerator: BaseModelLoadContext => FilesystemEnumerator) extends ModelLoaderContext { 4 | val domainExt: String = ".domain" 5 | 6 | val modelExt: String = ".model" 7 | 8 | val overlayExt: String = ".overlay" 9 | 10 | val parser: ModelParser = new ModelParserImpl() 11 | 12 | val enumerator: FilesystemEnumerator = makeEnumerator(this) 13 | 14 | val loader: ModelLoader = new ModelLoaderImpl(enumerator, parser, modelExt, domainExt, overlayExt) 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/common/ExtendedField.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.common 2 | 3 | import izumi.idealingua.model.il.ast.typed 4 | import izumi.idealingua.model.il.ast.typed.Field 5 | 6 | final case class FieldDef( 7 | definedBy: TypeId, 8 | definedWithIndex: Int, 9 | usedBy: TypeId, 10 | distance: Int, 11 | variance: List[Field] = List.empty, 12 | ) 13 | 14 | final case class ExtendedField(field: typed.Field, defn: FieldDef) { 15 | override def toString: TypeName = s"${defn.usedBy}#$field <- ${defn.definedBy}.${defn.definedWithIndex} (distance: ${defn.distance})" 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RAdtMember.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.il.ast.typed.AdtMember 5 | 6 | class RAdtMember(context: IDLRenderingContext) extends Renderable[AdtMember] { 7 | import context._ 8 | override def render(field: AdtMember): String = { 9 | val t = field.typeId.render() 10 | val repr = field.memberName match { 11 | case Some(name) => 12 | s"$t as $name" 13 | case None => 14 | t 15 | } 16 | 17 | context.meta.withMeta(field.meta, repr) 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Authorization/AuthBasic.cs: -------------------------------------------------------------------------------- 1 | 2 | namespace IRT.Transport.Authorization { 3 | class AuthBasic: AuthMethod { 4 | public string User; 5 | public string Pass; 6 | 7 | public AuthBasic(string user = null, string pass = null) { 8 | User = user; 9 | Pass = pass; 10 | } 11 | 12 | public override bool FromValue(string value) { 13 | return false; 14 | } 15 | 16 | public override string ToValue() { 17 | return "Basic " + User + ":" + Pass; 18 | } 19 | } 20 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/test/scala/izumi/idealingua/runtime/rpc/http4s/fixtures/TestContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s.fixtures 2 | 3 | sealed trait TestContext { 4 | def user: String 5 | } 6 | 7 | final case class PrivateContext(user: String) extends TestContext { 8 | override def toString: String = s"private: $user" 9 | } 10 | 11 | final case class ProtectedContext(user: String) extends TestContext { 12 | override def toString: String = s"protected: $user" 13 | } 14 | 15 | final case class PublicContext(user: String) extends TestContext { 16 | override def toString: String = s"public: $user" 17 | } 18 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/togolang/extensions/GoLangTranslatorExtensions.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.togolang.extensions 2 | 3 | import izumi.idealingua.translator.togolang.GLTContext 4 | 5 | class GoLangTranslatorExtensions(ctx: GLTContext, extensions: Seq[GoLangTranslatorExtension]) { 6 | def extend[S, P]( 7 | source: S, 8 | entity: P, 9 | entityTransformer: GoLangTranslatorExtension => (GLTContext, S, P) => P, 10 | ): P = { 11 | extensions.foldLeft(entity) { 12 | case (acc, v) => 13 | entityTransformer(v)(ctx, source, acc) 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/extensions/ProtobufTranslatorExtensions.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf.extensions 2 | 3 | import izumi.idealingua.translator.toprotobuf.PBTContext 4 | 5 | class ProtobufTranslatorExtensions(ctx: PBTContext, extensions: Seq[ProtobufTranslatorExtension]) { 6 | def extend[S, P]( 7 | source: S, 8 | entity: P, 9 | entityTransformer: ProtobufTranslatorExtension => (PBTContext, S, P) => P, 10 | ): P = { 11 | extensions.foldLeft(entity) { 12 | case (acc, v) => 13 | entityTransformer(v)(ctx, source, acc) 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RBuzzer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.fundamentals.platform.strings.IzString._ 5 | import izumi.idealingua.model.il.ast.typed._ 6 | 7 | class RBuzzer(context: IDLRenderingContext) extends Renderable[Buzzer] { 8 | override def render(buzzer: Buzzer): String = { 9 | val out = 10 | s"""buzzer ${buzzer.id.name} { 11 | |${buzzer.events.map(context.methods.renderMethod("line", _)).mkString("\n").shift(2)} 12 | |} 13 | """.stripMargin 14 | context.meta.withMeta(buzzer.meta, out) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/totypescript/products/RenderableCogenProduct.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.totypescript.products 2 | 3 | trait RenderableCogenProduct { 4 | def preamble: String 5 | def render: List[String] 6 | def renderHeader: List[String] 7 | def isEmpty: Boolean = render.isEmpty 8 | } 9 | 10 | object RenderableCogenProduct { 11 | def empty: RenderableCogenProduct = new RenderableCogenProduct { 12 | override def render: List[String] = List.empty 13 | override def renderHeader: List[String] = List.empty 14 | override def preamble: String = "" 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RAnno.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.il.ast.typed.{Anno, ConstValue} 5 | 6 | class RAnno(context: IDLRenderingContext) extends Renderable[Anno] { 7 | import context._ 8 | override def render(anno: Anno): String = { 9 | val vals = anno.values.map { 10 | case (name, v: ConstValue.Typed) => 11 | s"$name: ${v.typeId.render()} = ${(v: ConstValue).render()}" 12 | case (name, v) => 13 | s"$name = ${v.render()}" 14 | }.mkString(", ") 15 | 16 | s"@${anno.name}($vals)" 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RService.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.fundamentals.platform.strings.IzString._ 5 | import izumi.idealingua.model.il.ast.typed._ 6 | 7 | class RService(context: IDLRenderingContext) extends Renderable[Service] { 8 | override def render(service: Service): String = { 9 | val out = 10 | s"""service ${service.id.name} { 11 | |${service.methods.map(context.methods.renderMethod("def", _)).mkString("\n").shift(2)} 12 | |} 13 | """.stripMargin 14 | context.meta.withMeta(service.meta, out) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/IRTWrappedService.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | trait IRTWrappedService[F[_, _], -C] { self => 4 | def serviceId: IRTServiceId 5 | 6 | def allMethods: Map[IRTMethodId, IRTMethodWrapper[F, C]] 7 | 8 | final def contramap[D](f: D => C): IRTWrappedService[F, D] = { 9 | new IRTWrappedService[F, D] { 10 | override final val serviceId: IRTServiceId = self.serviceId 11 | override final val allMethods: Map[IRTMethodId, IRTMethodWrapper[F, D]] = { 12 | self.allMethods.map { case (k, v) => k -> v.contramap(f) } 13 | } 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/tocsharp/products/RenderableCogenProduct.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.tocsharp.products 2 | 3 | trait RenderableCogenProduct { 4 | def render: List[String] 5 | def renderHeader: List[String] 6 | def renderTests: List[String] 7 | def isEmpty: Boolean = render.isEmpty 8 | } 9 | 10 | object RenderableCogenProduct { 11 | def empty: RenderableCogenProduct = new RenderableCogenProduct { 12 | override def render: List[String] = List.empty 13 | override def renderHeader: List[String] = List.empty 14 | override def renderTests: List[String] = List.empty 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/togolang/products/RenderableCogenProduct.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.togolang.products 2 | 3 | trait RenderableCogenProduct { 4 | def render: List[String] 5 | def renderHeader: List[String] 6 | def renderTests: List[String] 7 | def isEmpty: Boolean = render.isEmpty 8 | } 9 | 10 | object RenderableCogenProduct { 11 | def empty: RenderableCogenProduct = new RenderableCogenProduct { 12 | override def render: List[String] = List.empty 13 | override def renderHeader: List[String] = List.empty 14 | override def renderTests: List[String] = List.empty 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/totypescript/extensions/TypeScriptTranslatorExtensions.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.totypescript.extensions 2 | 3 | import izumi.idealingua.translator.totypescript.TSTContext 4 | 5 | class TypeScriptTranslatorExtensions(ctx: TSTContext, extensions: Seq[TypeScriptTranslatorExtension]) { 6 | def extend[S, P]( 7 | source: S, 8 | entity: P, 9 | entityTransformer: TypeScriptTranslatorExtension => (TSTContext, S, P) => P, 10 | ): P = { 11 | extensions.foldLeft(entity) { 12 | case (acc, v) => 13 | entityTransformer(v)(ctx, source, acc) 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/buzzers.domain: -------------------------------------------------------------------------------- 1 | domain idltest.events 2 | 3 | enum EnumType { 4 | EnumA, 5 | EnumB 6 | } 7 | 8 | data BranchA { 9 | a: str 10 | } 11 | 12 | data BranchB { 13 | b: str 14 | } 15 | 16 | adt ADTType { 17 | // Ephemeral activity 18 | BranchA 19 | BranchB 20 | } 21 | 22 | buzzer TestBuzzer { 23 | line empty() 24 | line userRegistered(firstName: str, secondName: str) 25 | line hello(name: str): str 26 | line enumInput(value: EnumType): str 27 | line enumInputVoid(value: EnumType) 28 | line adtInput(value: ADTType): str 29 | line adtInputVoid(value: ADTType) 30 | } 31 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RStreams.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.fundamentals.platform.strings.IzString._ 5 | import izumi.idealingua.model.il.ast.typed.Streams 6 | 7 | class RStreams(context: IDLRenderingContext) extends Renderable[Streams] { 8 | import context._ 9 | 10 | override def render(streams: Streams): String = { 11 | val out = 12 | s"""streams ${streams.id.name} { 13 | |${streams.streams.map(_.render()).mkString("\n").shift(2)} 14 | |} 15 | """.stripMargin 16 | context.meta.withMeta(streams.meta, out) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/domains/DomainMeshResolved.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.domains 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | import izumi.idealingua.model.il.ast.raw.defns.{RawNodeMeta, RawTopLevelDefn} 5 | import izumi.idealingua.model.il.ast.raw.models.Inclusion 6 | import izumi.idealingua.model.loader.FSPath 7 | 8 | trait DomainMeshResolved { 9 | def id: DomainId 10 | def imports: Seq[Import] 11 | def members: Seq[RawTopLevelDefn] 12 | def referenced: Map[DomainId, DomainMeshResolved] 13 | def origin: FSPath 14 | def directInclusions: Seq[Inclusion] 15 | def meta: RawNodeMeta 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/structures/FieldConflicts.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.structures 2 | 3 | import izumi.idealingua.model.common.ExtendedField 4 | 5 | import scala.collection.mutable 6 | 7 | final case class FieldConflicts( 8 | goodFields: mutable.LinkedHashMap[String, ExtendedField], 9 | softConflicts: mutable.LinkedHashMap[String, ExtendedField], 10 | hardConflicts: mutable.LinkedHashMap[String, Seq[ExtendedField]], 11 | ) { 12 | def good: List[ExtendedField] = goodFields.values.toList 13 | def soft: List[ExtendedField] = softConflicts.values.toList 14 | def all: List[ExtendedField] = good ++ soft 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/layout/SbtDslOp.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.layout 2 | 3 | sealed trait SbtDslOp 4 | 5 | object SbtDslOp { 6 | 7 | final case class Append[T](v: T, scope: List[Scope]) extends SbtDslOp 8 | object Append { 9 | def apply[T](v: T, scope: Scope = Scope.ThisBuild): Append[T] = { 10 | new Append[T](v, List(scope)) 11 | } 12 | } 13 | 14 | final case class Assign[T](v: T, scope: List[Scope]) extends SbtDslOp 15 | object Assign { 16 | def apply[T](v: T, scope: Scope = Scope.ThisBuild): Assign[T] = { 17 | new Assign[T](v, List(scope)) 18 | } 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/substraction.domain: -------------------------------------------------------------------------------- 1 | domain idltest.substraction 2 | 3 | mixin Identified { 4 | id: str 5 | } 6 | 7 | mixin User1 { 8 | name: str 9 | id: str 10 | pass: str 11 | } 12 | 13 | mixin PublicUser1 { 14 | + User1 15 | - Identified 16 | - pass: str 17 | } 18 | 19 | 20 | mixin PersonalAttributes { 21 | ssn: str 22 | } 23 | 24 | mixin SecurityAttributes { 25 | & PersonalAttributes 26 | password: str 27 | } 28 | 29 | id UserId { 30 | _: uid 31 | } 32 | 33 | data User2 { 34 | + SecurityAttributes 35 | name: str 36 | } 37 | 38 | data PublicUser2 { 39 | + User2 40 | - SecurityAttributes 41 | } 42 | 43 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/tocsharp/CSTContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.tocsharp 2 | 3 | import izumi.idealingua.model.typespace.Typespace 4 | import izumi.idealingua.translator.tocsharp.extensions.{CSharpTranslatorExtension, CSharpTranslatorExtensions} 5 | import izumi.idealingua.translator.tocsharp.tools.ModuleTools 6 | 7 | class CSTContext( 8 | val typespace: Typespace, 9 | extensions: Seq[CSharpTranslatorExtension], 10 | ) { 11 | 12 | final val modules = new ModuleTools() 13 | 14 | final val tools = new CSharpTranslationTools() 15 | final val ext = { 16 | new CSharpTranslatorExtensions(this, extensions) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/togolang/GLTContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.togolang 2 | 3 | import izumi.idealingua.model.typespace.Typespace 4 | import izumi.idealingua.translator.togolang.extensions.{GoLangTranslatorExtension, GoLangTranslatorExtensions} 5 | import izumi.idealingua.translator.togolang.tools.ModuleTools 6 | 7 | class GLTContext( 8 | val typespace: Typespace, 9 | extensions: Seq[GoLangTranslatorExtension], 10 | ) { 11 | 12 | final val modules = new ModuleTools() 13 | 14 | final val tools = new GoLangTranslationTools() 15 | final val ext = { 16 | new GoLangTranslatorExtensions(this, extensions) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/problems/IDLDiagnostics.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.problems 2 | 3 | case class IDLDiagnostics(issues: Vector[IDLError], warnings: Vector[IDLWarning]) { 4 | def ++(other: IDLDiagnostics): IDLDiagnostics = IDLDiagnostics(issues ++ other.issues, warnings ++ other.warnings) 5 | } 6 | 7 | object IDLDiagnostics { 8 | def empty: IDLDiagnostics = IDLDiagnostics(Vector.empty, Vector.empty) 9 | 10 | def apply(issues: Seq[IDLError]): IDLDiagnostics = new IDLDiagnostics(issues.toVector, Vector.empty) 11 | 12 | def apply(issues: Seq[IDLError], warnings: Seq[IDLWarning]): IDLDiagnostics = new IDLDiagnostics(issues.toVector, warnings.toVector) 13 | } 14 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/MetaRenderer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.idealingua.model.il.ast.typed.NodeMeta 4 | 5 | class MetaRenderer(context: IDLRenderingContext) { 6 | import context._ 7 | 8 | def withMeta(meta: NodeMeta, struct: String): String = { 9 | val maybeDoc = meta.doc.map { 10 | d => 11 | s"""/*${d.split('\n').map(v => s" *$v").mkString("\n").trim} 12 | | */""".stripMargin 13 | } 14 | 15 | val maybeAnno = meta.annos.map(_.render()) 16 | 17 | Seq( 18 | maybeDoc.toSeq, 19 | maybeAnno, 20 | Seq(struct), 21 | ).flatten 22 | .mkString("\n") 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/identifiers.domain: -------------------------------------------------------------------------------- 1 | domain idltest.identifiers 2 | 3 | id CompanyId { 4 | value: uid 5 | iid: i64 6 | } 7 | 8 | id UserId { 9 | value: uid 10 | company: uid 11 | } 12 | 13 | id BucketID { 14 | app: uid 15 | user: uid 16 | bucket: str 17 | } 18 | 19 | enum DepartmentEnum { 20 | Engineering 21 | Sales 22 | } 23 | 24 | id UserWithEnumId { 25 | value: uid 26 | company: uid 27 | dept: DepartmentEnum 28 | } 29 | 30 | id ComplexID { 31 | bucket: BucketID 32 | user: UserWithEnumId 33 | _: i32 34 | _: uid 35 | _: str 36 | } 37 | 38 | data KVIDGeneric { 39 | test: map[str, BucketID] 40 | } 41 | 42 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/auth/auth.token.ts: -------------------------------------------------------------------------------- 1 | import { AuthMethod } from './auth.method'; 2 | 3 | export class AuthToken extends AuthMethod{ 4 | public token: string; 5 | constructor(token: string) { 6 | super(); 7 | this.token = token; 8 | } 9 | 10 | public fromValue(value: string): Error { 11 | if (value.indexOf('Bearer ') !== 0) { 12 | return new Error('token authorization must start with Bearer, got ' + value) 13 | } 14 | this.token = value.substr(7); 15 | return undefined; 16 | } 17 | 18 | public toValue(): string { 19 | return 'Bearer ' + this.token; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /project/Versions.scala: -------------------------------------------------------------------------------- 1 | object V { 2 | // foundation 3 | 4 | val scalatest = "3.2.19" 5 | 6 | val http4s = "0.23.30" 7 | val http4s_blaze = "0.23.17" 8 | 9 | val scalameta = "4.13.7" // Not available for Scala 3 yet 10 | val fastparse = "3.1.1" // 3.0.0 is available for Scala 3 11 | 12 | val scala_xml = "2.4.0" 13 | 14 | val kind_projector = "0.13.3" 15 | 16 | val circe_derivation = "0.13.0-M5" 17 | val circe_generic_extras = "0.14.4" 18 | 19 | val scala_java_time = "2.6.0" 20 | 21 | // java-only dependencies below 22 | // java, we need it bcs http4s ws client isn't ready yet 23 | val asynchttpclient = "3.0.2" 24 | 25 | val slf4j = "1.7.30" 26 | val typesafe_config = "1.4.3" 27 | } 28 | -------------------------------------------------------------------------------- /.scala-steward.conf: -------------------------------------------------------------------------------- 1 | updates.pin = [ 2 | # use only Scala3 3.3 LTS 3 | { groupId = "org.scala-lang", artifactId="scala3-compiler", version = "3.3." }, 4 | { groupId = "org.scala-lang", artifactId="scala3-library", version = "3.3." }, 5 | { groupId = "org.scala-lang", artifactId="scala3-library_sjs1", version = "3.3." } 6 | ] 7 | 8 | pullRequests.frequency = "@monthly" 9 | 10 | pullRequests.grouping = [ 11 | # group scala updates & scoverage 12 | { name="scala-versions", "title"="Scala compiler updates", "filter"=[{"group" = "org.scala-lang"}, {"group" = "org.scoverage"}] }, 13 | # group everything else 14 | { name = "all", "title" = "Dependency updates", "filter" = [{"group" = "*"}] } 15 | ] 16 | 17 | updatePullRequests = "always" 18 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/AdtRenderer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf 2 | 3 | import izumi.idealingua.model.il.ast.typed.TypeDef.Adt 4 | import izumi.idealingua.translator.toprotobuf.products.CogenProducts 5 | import izumi.idealingua.translator.toprotobuf.types.ProtobufAdtMember 6 | 7 | final class AdtRenderer(ctx: PBTContext) { 8 | def defns(i: Adt): CogenProducts.ADT = { 9 | val self = ctx.conv.toProtobuf(i.id) 10 | val members = i.alternatives.map { 11 | alt => 12 | ProtobufAdtMember(alt.memberName, ctx.conv.toProtobuf(alt.typeId)) 13 | } 14 | ctx.ext.extend(i, CogenProducts.ADT(self, members), _.handleAdt) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/AliasRenderer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf 2 | 3 | import izumi.fundamentals.platform.strings.IzString._ 4 | import izumi.idealingua.model.il.ast.typed.TypeDef.Alias 5 | import izumi.idealingua.translator.toprotobuf.products.CogenProducts 6 | import izumi.idealingua.translator.toprotobuf.types.ProtobufField 7 | 8 | final class AliasRenderer(ctx: PBTContext) { 9 | def defns(i: Alias): CogenProducts.Message = { 10 | val self = ctx.conv.toProtobuf(i.id) 11 | val field = ProtobufField(i.id.name.uncapitalize, ctx.conv.toProtobuf(i.target)) 12 | ctx.ext.extend(i, CogenProducts.Message(self, List(field)), _.handleAlias) 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/TranslatorDescriptor.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator 2 | 3 | import izumi.idealingua.model.publishing.BuildManifest 4 | import izumi.idealingua.model.typespace.Typespace 5 | import izumi.idealingua.model.typespace.verification.VerificationRule 6 | 7 | trait TranslatorDescriptor[TypedOptions] { 8 | def language: IDLLanguage 9 | def defaultExtensions: Seq[TranslatorExtension] 10 | def defaultManifest: BuildManifest 11 | def typedOptions(options: UntypedCompilerOptions): TypedOptions 12 | def make(typespace: Typespace, options: UntypedCompilerOptions): Translator 13 | def makeHook(options: UntypedCompilerOptions): TranslationLayouter 14 | def rules: Seq[VerificationRule] 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/WebSocketMessageType.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | 4 | namespace IRT.Transport { 5 | public static class WebSocketMessageKind { 6 | public const string Failure = "?:failure"; 7 | public const string RpcRequest = "rpc:request"; 8 | public const string RpcResponse = "rpc:response"; 9 | public const string RpcFailure = "rpc:failure"; 10 | public const string BuzzerRequest = "buzzer:request"; 11 | public const string BuzzerResponse = "buzzer:response"; 12 | public const string BuzzerFailure = "buzzer:failure"; 13 | public const string StreamS2C = "stream:s2c"; 14 | public const string StreamC2S = "stream:c2s"; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/IRTCirceMarshaller.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | import izumi.functional.bio.IO2 4 | import io.circe.{DecodingFailure, Json} 5 | 6 | abstract class IRTCirceMarshaller { 7 | def encodeRequest: PartialFunction[IRTReqBody, Json] 8 | 9 | def encodeResponse: PartialFunction[IRTResBody, Json] 10 | 11 | def decodeRequest[Or[+_, +_]: IO2]: PartialFunction[IRTJsonBody, Or[DecodingFailure, IRTReqBody]] 12 | 13 | def decodeResponse[Or[+_, +_]: IO2]: PartialFunction[IRTJsonBody, Or[DecodingFailure, IRTResBody]] 14 | 15 | protected def decoded[Or[+_, +_]: IO2, V](result: Either[DecodingFailure, V]): Or[DecodingFailure, V] = { 16 | IO2[Or].fromEither(result) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /.mobala/steps/spec/ts_spec.sh: -------------------------------------------------------------------------------- 1 | Describe 'Typescript transpiler' 2 | Include ./.mobala/steps/lib/builders.sh 3 | 4 | Parameters:dynamic 5 | while read line; do 6 | %data "$line" 7 | done <<< "$(find ./idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs -maxdepth 1 -mindepth 1 -type d)" 8 | End 9 | 10 | It "builds Typescript Yarn project in $1" 11 | When call test_ts_yarn_prj "$1" 12 | The status should be success 13 | The output should match pattern '*' 14 | The stderr should match pattern '*' 15 | End 16 | 17 | It "builds Typescript Plain project in $1" 18 | When call test_ts_plain_prj "$1" 19 | The status should be success 20 | The output should match pattern '*' 21 | The stderr should match pattern '*' 22 | End 23 | End 24 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/types/ScalaStruct.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.types 2 | 3 | import izumi.idealingua.model.common.StructureId 4 | import izumi.idealingua.model.typespace.structures.{ConstAbstractStruct, Struct} 5 | 6 | class ScalaStruct( 7 | val fields: Struct, 8 | val unambigious: List[ScalaField], 9 | val ambigious: List[ScalaField], 10 | val all: List[ScalaField], // keeping separatedly to preserve order 11 | ) extends ConstAbstractStruct[ScalaField] { 12 | 13 | val id: StructureId = fields.id 14 | 15 | override protected def isLocal(f: ScalaField): Boolean = { 16 | f.field.defn.definedBy == id 17 | } 18 | } 19 | 20 | final case class PlainScalaStruct(all: List[ScalaField]) 21 | -------------------------------------------------------------------------------- /.mobala/steps/run-publish-scala.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | 4 | set -euo pipefail 5 | 6 | function run-publish-scala() { 7 | validate_publishing || exit 0 8 | 9 | if [[ ! -f "$SONATYPE_SECRET" ]] ; then 10 | echo "SONATYPE_SECRET=$SONATYPE_SECRET is not a file" 11 | exit 0 12 | fi 13 | 14 | echo "PUBLISH SCALA LIBRARIES..." 15 | 16 | if [[ "$CI_BRANCH" == "develop" ]] ; then 17 | sbt -batch -no-colors -v \ 18 | "$VERSION_COMMAND clean" \ 19 | "$VERSION_COMMAND package" \ 20 | "$VERSION_COMMAND publishSigned" 21 | else 22 | sbt -batch -no-colors -v \ 23 | "$VERSION_COMMAND clean" \ 24 | "$VERSION_COMMAND package" \ 25 | "$VERSION_COMMAND publishSigned" \ 26 | sonaUpload sonaRelease || exit 1 27 | fi 28 | 29 | } 30 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/structures/ConstAbstractStruct.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.structures 2 | 3 | trait ConstAbstractStruct[F] extends AbstractStruct[F] { 4 | override lazy val inherited: List[F] = super.inherited 5 | 6 | override lazy val local: List[F] = super.local 7 | 8 | override lazy val unambigiousInherited: List[F] = super.unambigiousInherited 9 | 10 | override lazy val localOrAmbigious: List[F] = super.localOrAmbigious 11 | 12 | override lazy val isScalar: Boolean = super.isScalar 13 | 14 | override lazy val isComposite: Boolean = super.isComposite 15 | 16 | override lazy val isEmpty: Boolean = super.isEmpty 17 | 18 | override lazy val nonEmpty: Boolean = super.nonEmpty 19 | 20 | } 21 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/domains/DomainMeshLoaded.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.domains 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | import izumi.idealingua.model.il.ast.raw.defns._ 5 | import izumi.idealingua.model.il.ast.raw.models.Inclusion 6 | import izumi.idealingua.model.loader.FSPath 7 | 8 | final case class DomainMeshLoaded( 9 | id: DomainId, 10 | origin: FSPath, 11 | directInclusions: Seq[Inclusion], 12 | originalImports: Seq[Import], 13 | meta: RawNodeMeta, 14 | types: Seq[RawTypeDef], 15 | services: Seq[RawService], 16 | buzzers: Seq[RawBuzzer], 17 | streams: Seq[RawStreams], 18 | consts: Seq[RawConstBlock], 19 | imports: Seq[SingleImport], 20 | defn: DomainMeshResolved, 21 | ) 22 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/dtofields.domain: -------------------------------------------------------------------------------- 1 | domain idltest.dtofields 2 | 3 | mixin IntPair { 4 | x: i32 5 | y: i32 6 | } 7 | 8 | mixin WHPair { 9 | w: i32 10 | h: i32 11 | } 12 | 13 | mixin Metadata { 14 | id: str 15 | name: str 16 | } 17 | 18 | mixin PointLike { 19 | & Metadata 20 | + IntPair 21 | } 22 | 23 | data Point { 24 | & Metadata 25 | & WHPair 26 | + IntPair 27 | ownfield: str 28 | name: str 29 | export: bool 30 | } 31 | 32 | mixin NullableContent { 33 | a: i32 34 | } 35 | 36 | data NullableObj { 37 | &NullableContent 38 | } 39 | 40 | data OptionalObj { 41 | no: opt[NullableObj] 42 | } 43 | 44 | alias NullObj = NullableObj 45 | 46 | data ListObj { 47 | all: list[NullObj] 48 | } 49 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/scala/izumi/r2/idealingua/test/impls/AbstractGreeterServer.scala: -------------------------------------------------------------------------------- 1 | package izumi.r2.idealingua.test.impls 2 | 3 | import izumi.functional.bio.{F, IO2} 4 | import izumi.r2.idealingua.test.generated.* 5 | 6 | abstract class AbstractGreeterServer[F[+_, +_]: IO2, C] extends GreeterServiceServer[F, C] { 7 | override def greet(ctx: C, name: String, surname: String): Just[String] = F.pure(s"Hi, $name $surname!") 8 | override def sayhi(ctx: C): Just[String] = F.pure(s"Hi! With $ctx.") 9 | override def alternative(ctx: C): F[Long, String] = F.fromEither(Right("value")) 10 | override def nothing(ctx: C): F[Nothing, String] = F.pure("") 11 | } 12 | 13 | object AbstractGreeterServer { 14 | class Impl[F[+_, +_]: IO2, C] extends AbstractGreeterServer[F, C] 15 | } 16 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/DefBuzzer.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser 2 | 3 | import izumi.idealingua.il.parser.structure._ 4 | import izumi.idealingua.model.il.ast.raw.defns.{RawBuzzer, RawMethod, RawTopLevelDefn} 5 | import fastparse.NoWhitespace._ 6 | import fastparse._ 7 | 8 | class DefBuzzer(context: IDLParserContext) { 9 | 10 | import context._ 11 | import sep._ 12 | 13 | // other method kinds should be added here 14 | def methods[$: P]: P[Seq[RawMethod]] = P(defSignature.method(kw.defe).rep(sep = any)) 15 | 16 | def buzzerBlock[$: P]: P[RawTopLevelDefn.TLDBuzzer] = P(metaAgg.cblock(kw.buzzer, methods)).map { 17 | case (c, i, v) => RawBuzzer(i.toBuzzerId, v.toList, c) 18 | } 19 | .map(RawTopLevelDefn.TLDBuzzer.apply) 20 | 21 | } 22 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Server/WebSocketServer.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | using System.IO; 4 | using System.Net; 5 | using System.Threading; 6 | using System.Linq; 7 | using System.Net.Mime; 8 | using System.Text; 9 | using IRT.Marshaller; 10 | using WebSocketSharp; 11 | using WebSocketSharp.Net.WebSockets; 12 | using WebSocketSharp.Server; 13 | using ErrorEventArgs = WebSocketSharp.ErrorEventArgs; 14 | 15 | namespace IRT.Transport.Server { 16 | public class WebSocketServer: WebSocketServerGeneric { 17 | public WebSocketServer(string endpoint, IJsonMarshaller marshaller, ILogger logger, 18 | IWebSocketServerHandlers handlers = null): base(endpoint, marshaller, logger, handlers) { 19 | } 20 | } 21 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/DefService.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser 2 | 3 | import izumi.idealingua.il.parser.structure._ 4 | import izumi.idealingua.model.il.ast.raw.defns.{RawMethod, RawService, RawTopLevelDefn} 5 | import fastparse.NoWhitespace._ 6 | import fastparse._ 7 | 8 | class DefService(context: IDLParserContext) { 9 | 10 | import context._ 11 | import sep._ 12 | 13 | // other method kinds should be added here 14 | def methods[$: P]: P[Seq[RawMethod]] = P(defSignature.method(kw.defm).rep(sep = any)) 15 | 16 | def serviceBlock[$: P]: P[RawTopLevelDefn.TLDService] = P(metaAgg.cblock(kw.service, methods)).map { 17 | case (c, i, v) => RawService(i.toServiceId, v.toList, c) 18 | } 19 | .map(RawTopLevelDefn.TLDService.apply) 20 | 21 | } 22 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/IRTOutputMiddleware.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | import io.circe.Json 4 | import izumi.functional.bio.{Applicative2, F} 5 | 6 | trait IRTOutputMiddleware[F[_, _], C] { 7 | def apply( 8 | methodId: IRTMethodId 9 | )(context: C, 10 | response: IRTResBody, 11 | encodedResponse: Json, 12 | ): F[Throwable, Json] 13 | } 14 | 15 | object IRTOutputMiddleware { 16 | def empty[F[+_, +_]: Applicative2, C] = new Empty[F, C] 17 | 18 | final class Empty[F[+_, +_]: Applicative2, C] extends IRTOutputMiddleware[F, C] { 19 | override def apply(methodId: IRTMethodId)(context: C, response: IRTResBody, encodedResponse: Json): F[Throwable, Json] = { 20 | F.pure(encodedResponse) 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/nuget/publish.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -xe 3 | 4 | THISDIR="$( cd "$(dirname "$0")" ; pwd -P )" 5 | 6 | pushd . 7 | cd $THISDIR/solution 8 | 9 | #rm -rf *.nupkg 10 | 11 | [[ "$CI_PULL_REQUEST" != "false" ]] && exit 0 12 | [[ -z "$TOKEN_NUGET" ]] && exit 0 13 | [[ -z "$CI_BUILD_UNIQ_SUFFIX" ]] && exit 0 14 | 15 | sed -i 's/0.0.1-build.0/'${PROJECT_VERSION}'/g' Izumi.RPC.Runtime.CS.IRT/Izumi.RPC.Runtime.CS.IRT.csproj 16 | 17 | if [[ "$CI_BRANCH_TAG" =~ ^v.*$ ]] ; then 18 | dotnet build -c Release 19 | else 20 | dotnet build -c Release --version-suffix "alpha.${CI_BUILD_UNIQ_SUFFIX}" 21 | fi 22 | 23 | find . -name '*.nupkg' -type f -print0 | xargs -I % -n 1 -0 dotnet nuget push % -k "${TOKEN_NUGET}" --source https://api.nuget.org/v3/index.json 24 | 25 | popd 26 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/structures/AbstractStruct.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.structures 2 | 3 | trait AbstractStruct[F] { 4 | def unambigious: List[F] 5 | 6 | def ambigious: List[F] 7 | 8 | def all: List[F] 9 | 10 | def inherited: List[F] = all.filterNot(isLocal) 11 | 12 | def local: List[F] = all.filter(isLocal) 13 | 14 | def unambigiousInherited: List[F] = unambigious.filterNot(isLocal) 15 | 16 | def localOrAmbigious: List[F] = ambigious ++ local 17 | 18 | def isScalar: Boolean = size == 1 19 | 20 | def isComposite: Boolean = size > 1 21 | 22 | def isEmpty: Boolean = size == 0 23 | 24 | def nonEmpty: Boolean = !isEmpty 25 | 26 | private def size: Int = all.size 27 | 28 | protected def isLocal(f: F): Boolean 29 | 30 | } 31 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/types/ScalaType.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.types 2 | 3 | import izumi.idealingua.model.JavaType 4 | 5 | import scala.meta.{Init, Term, Type} 6 | 7 | trait ScalaType { 8 | def parameterize(names: List[Type]): ScalaType 9 | def parameterize(names: String*): ScalaType = { 10 | parameterize(names.map(Type.Name.apply).toList) 11 | } 12 | 13 | def termBase: Term.Ref 14 | def termName: Term.Name 15 | def termArgs: Seq[Term] 16 | def termFull: Term 17 | def termAbsolute: Term 18 | 19 | def typeBase: Type.Ref 20 | def typeArgs: Seq[Type] 21 | def typeName: Type.Name 22 | def typeFull: Type 23 | 24 | def typeAbsolute: Type 25 | 26 | def fullJavaType: JavaType 27 | def init(constructorArgs: Term*): Init 28 | } 29 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/main/scala/izumi/idealingua/runtime/rpc/http4s/IRTHttpFailureException.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s 2 | 3 | import izumi.idealingua.runtime.rpc.IRTTransportException 4 | import org.http4s.Status 5 | 6 | abstract class IRTHttpFailureException( 7 | message: String, 8 | val status: Status, 9 | cause: Option[Throwable] = None, 10 | ) extends IRTTransportException(message, cause) 11 | 12 | case class IRTUnexpectedHttpStatus(override val status: Status) extends IRTHttpFailureException(s"Unexpected http status: $status", status) 13 | case class IRTNoCredentialsException(override val status: Status) extends IRTHttpFailureException("No valid credentials", status) 14 | case class IRTBadCredentialsException(override val status: Status) extends IRTHttpFailureException("No valid credentials", status) 15 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/IRTMethodWrapper.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | abstract class IRTMethodWrapper[F[_, _], -C] { self => 4 | final type Just[T] = F[Nothing, T] 5 | 6 | val signature: IRTMethodSignature 7 | val marshaller: IRTCirceMarshaller 8 | 9 | def invoke(ctx: C, input: signature.Input): Just[signature.Output] 10 | 11 | final def contramap[D](f: D => C): IRTMethodWrapper[F, D] = { 12 | new IRTMethodWrapper[F, D] { 13 | override final val signature: self.signature.type = self.signature 14 | override final val marshaller: self.marshaller.type = self.marshaller 15 | override final def invoke(ctx: D, input: self.signature.Input): F[Nothing, self.signature.Output] = { 16 | self.invoke(f(ctx), input) 17 | } 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/layout/ScalaNamingConvention.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.layout 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | import izumi.idealingua.model.publishing.ProjectNamingRule 5 | import izumi.idealingua.translator.BaseNamingConvention 6 | 7 | class ScalaNamingConvention(rule: ProjectNamingRule) { 8 | private val naming = new BaseNamingConvention(rule) 9 | 10 | def projectId(did: DomainId): String = { 11 | naming.baseProjectId(did).mkString("-").toLowerCase() 12 | } 13 | 14 | def pkgId: String = specialId(None) 15 | 16 | def bundleId: String = specialId(Some("bundle")) 17 | 18 | def specialId(what: Option[String]): String = { 19 | (what.toSeq ++ naming.baseProjectId(Seq.empty)).map(_.toLowerCase).mkString("-") 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/togolang/extensions/GoLangTranslatorExtension.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.togolang.extensions 2 | 3 | import izumi.idealingua.translator.TranslatorExtension 4 | 5 | trait GoLangTranslatorExtension extends TranslatorExtension { 6 | 7 | // def handleInterface(ctx: TSTContext, interface: Interface, product: InterfaceProduct): InterfaceProduct = { 8 | // discard(ctx, interface) 9 | // product 10 | // } 11 | // 12 | // def handleEnum(ctx: TSTContext, enum: TypeDef.Enumeration, product: EnumProduct): EnumProduct = { 13 | // discard(ctx, enum) 14 | // product 15 | // } 16 | // 17 | // def handleIdentifier(ctx: TSTContext, identifier: TypeDef.Identifier, product: IdentifierProduct): IdentifierProduct = { 18 | // discard(ctx, identifier) 19 | // product 20 | // } 21 | } 22 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/types/ProtobufType.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf.types 2 | 3 | import izumi.idealingua.model.common.Package 4 | 5 | final case class ProtobufType(pkg: Package, name: String, args: List[ProtobufType] = Nil, optional: Option[Boolean] = Some(false)) { 6 | def fullName: String = { 7 | if (pkg.nonEmpty) { 8 | s"${pkg.mkString(".")}.$name" 9 | } else { 10 | name 11 | } 12 | } 13 | 14 | def imports: Set[String] = { 15 | ProtobufType.importFromPackage(pkg) ++ args.flatMap(_.imports) 16 | } 17 | } 18 | 19 | object ProtobufType { 20 | def importFromPackage(pkg: Package): Set[String] = { 21 | if (pkg.nonEmpty) { 22 | Set(s"""import "${pkg.mkString("/")}.proto";""") 23 | } else { 24 | Set.empty 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/extensions/ScalaTranslatorExtensions.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.extensions 2 | 3 | import izumi.idealingua.model.output.Module 4 | import izumi.idealingua.translator.toscala.STContext 5 | 6 | class ScalaTranslatorExtensions(ctx: STContext, extensions: Seq[ScalaTranslatorExtension]) { 7 | def extend(modules: Seq[Module]): Seq[Module] = { 8 | extensions.foldLeft(modules) { 9 | case (acc, ext) => 10 | ext.handleModules(ctx, acc) 11 | } 12 | } 13 | 14 | def extend[S, P]( 15 | source: S, 16 | entity: P, 17 | entityTransformer: ScalaTranslatorExtension => (STContext, S, P) => P, 18 | ): P = { 19 | extensions.foldLeft(entity) { 20 | case (acc, v) => 21 | entityTransformer(v)(ctx, source, acc) 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/verification/TypespaceVerifier.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.verification 2 | 3 | import izumi.idealingua.model.problems.IDLDiagnostics 4 | import izumi.idealingua.model.typespace.Typespace 5 | import izumi.idealingua.model.typespace.verification.rules._ 6 | 7 | class TypespaceVerifier(ts: Typespace, rules: Seq[VerificationRule]) { 8 | def verify(): IDLDiagnostics = { 9 | val basicRules = Vector( 10 | DuplicateMemberRule, 11 | AdtMembersRule, 12 | BasicNamingConventionsRule, 13 | AdtConflictsRule, 14 | CyclicUsageRule, 15 | CyclicInheritanceRule, 16 | CyclicImportsRule.auto(ts), 17 | ) 18 | 19 | val additional = (basicRules ++ rules).map(_.verify(ts)) 20 | 21 | additional.fold(IDLDiagnostics.empty)(_ ++ _) 22 | } 23 | 24 | } 25 | 26 | object TypespaceVerifier {} 27 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/auth/auth.apikey.ts: -------------------------------------------------------------------------------- 1 | import { AuthMethod } from './auth.method'; 2 | 3 | export class AuthApiKey extends AuthMethod { 4 | public apiKey: string; 5 | constructor(apiKey: string) { 6 | super(); 7 | this.apiKey = apiKey; 8 | } 9 | 10 | public fromValue(value: string): Error { 11 | if (value.toLowerCase().indexOf('api-key ') === 0) { 12 | this.apiKey = value.substr(8); 13 | return undefined; 14 | } 15 | 16 | if (value.toLowerCase().indexOf('apikey ') === 0) { 17 | this.apiKey = value.substr(7); 18 | return undefined; 19 | } 20 | 21 | return new Error('api key authorization must start with ApiKey, got ' + value) 22 | } 23 | 24 | public toValue(): string { 25 | return 'Api-Key ' + this.apiKey; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/algebraics.domain: -------------------------------------------------------------------------------- 1 | domain idltest.algebraics 2 | 3 | data Success { message: str } 4 | data Failure { code: int8 } 5 | 6 | 7 | adt Alternative { 8 | Success as TestSuccess 9 | Failure 10 | } 11 | 12 | adt ShortSyntax = Success as TestSuccess | Failure 13 | 14 | id AdtTestID { 15 | id: str 16 | } 17 | 18 | data ComplexAdt { 19 | id: AdtTestID 20 | } 21 | 22 | data ComplexAdt2 { 23 | id: AdtTestID 24 | } 25 | 26 | adt AdtTester { 27 | ComplexAdt 28 | ComplexAdt2 29 | } 30 | 31 | //https://github.com/7mind/izumi/issues/363 32 | /* 33 | adt Bad0 { 34 | Success 35 | Failure 36 | } 37 | 38 | adt Bad1 { 39 | Success 40 | Failure 41 | } 42 | 43 | adt Bad { 44 | Bad0 45 | Bad1 46 | } 47 | */ 48 | 49 | mixin AFace { 50 | a: i32 51 | } 52 | 53 | adt AdtWithInterface { 54 | AFace 55 | Success 56 | } 57 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/npmjs/tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions" : { 3 | "module" : "commonjs", 4 | "target" : "es5", 5 | "lib" : [ 6 | "es6", 7 | "dom" 8 | ], 9 | "sourceMap" : true, 10 | "allowJs" : false, 11 | "moduleResolution" : "node", 12 | "rootDirs" : [ 13 | "irt" 14 | ], 15 | "outDir" : "dist", 16 | "declaration" : true, 17 | "baseUrl" : ".", 18 | "paths" : { 19 | "*" : [ 20 | "irt/*", 21 | "node_modules/*" 22 | ] 23 | }, 24 | "forceConsistentCasingInFileNames" : true, 25 | "noImplicitReturns" : true, 26 | "noImplicitThis" : true, 27 | "noImplicitAny" : true, 28 | "strictNullChecks" : false, 29 | "ignoreDeprecations": "5.0", 30 | "experimentalDecorators" : true, 31 | "removeComments" : true, 32 | "preserveConstEnums" : true 33 | }, 34 | "compileOnSave" : false 35 | } 36 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/types/ProtobufMethod.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf.types 2 | 3 | import izumi.idealingua.translator.toprotobuf.types.ProtobufMethod.ProtobufOutput 4 | 5 | final case class ProtobufMethod(name: String, inputs: List[ProtobufField], output: ProtobufOutput) 6 | 7 | object ProtobufMethod { 8 | sealed trait ProtobufOutput 9 | 10 | sealed trait NonAlternativeOutput extends ProtobufOutput 11 | 12 | case object Void extends NonAlternativeOutput 13 | final case class ADT(members: List[ProtobufAdtMember]) extends NonAlternativeOutput 14 | final case class Single(tpe: ProtobufType) extends NonAlternativeOutput 15 | final case class Structure(fields: List[ProtobufField]) extends NonAlternativeOutput 16 | 17 | final case class Alternative(success: NonAlternativeOutput, failure: NonAlternativeOutput) extends ProtobufOutput 18 | } 19 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/main/scala/izumi/idealingua/runtime/rpc/http4s/IRTAuthenticator.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s 2 | 3 | import io.circe.Json 4 | import izumi.functional.bio.{Applicative2, F} 5 | import izumi.idealingua.runtime.rpc.IRTMethodId 6 | import org.http4s.Headers 7 | 8 | import java.net.InetAddress 9 | 10 | abstract class IRTAuthenticator[F[_, _], AuthCtx, RequestCtx] { 11 | def authenticate(authContext: AuthCtx, body: Option[Json], methodId: Option[IRTMethodId]): F[Nothing, Option[RequestCtx]] 12 | } 13 | 14 | object IRTAuthenticator { 15 | def unit[F[+_, +_]: Applicative2, C]: IRTAuthenticator[F, C, Unit] = new IRTAuthenticator[F, C, Unit] { 16 | override def authenticate(authContext: C, body: Option[Json], methodId: Option[IRTMethodId]): F[Nothing, Option[Unit]] = F.pure(Some(())) 17 | } 18 | final case class AuthContext(headers: Headers, networkAddress: Option[InetAddress]) 19 | } 20 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawTopLevelDefn.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | sealed trait RawTopLevelDefn 4 | 5 | object RawTopLevelDefn { 6 | 7 | sealed trait TypeDefn extends RawTopLevelDefn 8 | 9 | final case class TLDBaseType(v: RawTypeDef.WithId) extends TypeDefn 10 | 11 | final case class TLDService(v: RawService) extends RawTopLevelDefn 12 | 13 | final case class TLDBuzzer(v: RawBuzzer) extends RawTopLevelDefn 14 | 15 | // not supported by cogen yet 16 | final case class TLDStreams(v: RawStreams) extends RawTopLevelDefn 17 | 18 | final case class TLDConsts(v: RawConstBlock) extends RawTopLevelDefn 19 | 20 | final case class TLDNewtype(v: RawTypeDef.NewType) extends TypeDefn 21 | 22 | final case class TLDDeclared(v: RawTypeDef.DeclaredType) extends TypeDefn 23 | 24 | final case class TLDForeignType(v: RawTypeDef.ForeignType) extends TypeDefn 25 | 26 | } 27 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/verification/DuplicateDomainsRule.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader.verification 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | import izumi.idealingua.model.loader.{FSPath, LoadedDomain} 5 | import izumi.idealingua.model.problems.{IDLDiagnostics, PostError} 6 | 7 | import scala.annotation.nowarn 8 | 9 | @nowarn("msg=Unused import") 10 | object DuplicateDomainsRule extends GlobalVerificationRule { 11 | import scala.collection.compat.* 12 | 13 | override def check(successful: Seq[LoadedDomain.Success]): IDLDiagnostics = { 14 | val duplicates: Map[DomainId, Seq[FSPath]] = 15 | successful.map(s => s.typespace.domain.id -> s.path).groupBy(_._1).filter(_._2.size > 1).view.mapValues(_.map(_._2)).toMap 16 | 17 | if (duplicates.isEmpty) { 18 | IDLDiagnostics.empty 19 | } else { 20 | IDLDiagnostics(Vector(PostError.DuplicatedDomains(duplicates))) 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/structure/Aggregates.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser.structure 2 | 3 | import izumi.idealingua.model.il.ast.raw.typeid.ParsedId 4 | import fastparse.NoWhitespace._ 5 | import fastparse._ 6 | 7 | trait Aggregates 8 | extends Separators 9 | with Identifiers { 10 | 11 | def enclosed[T](defparser: => P[T])(implicit v: P[?]): P[T] = { 12 | P(("{" ~ any ~ defparser ~ any ~ "}") | "(" ~ any ~ defparser ~ any ~ ")") 13 | } 14 | 15 | def enclosedB[T](defparser: => P[T])(implicit v: P[?]): P[T] = { 16 | P("[" ~ any ~ defparser ~ any ~ "]") 17 | } 18 | 19 | 20 | def starting[T](keyword: => P[Unit], defparser: => P[T])(implicit v: P[?]): P[(ParsedId, T)] = { 21 | kw(keyword, idShort ~ inline ~ defparser) 22 | } 23 | 24 | def block[T](keyword: => P[Unit], defparser: => P[T])(implicit v: P[?]): P[(ParsedId, T)] = { 25 | starting(keyword, enclosed(defparser)) 26 | } 27 | 28 | 29 | } 30 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/structures/Struct.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.structures 2 | 3 | import izumi.idealingua.model.common.TypeId.InterfaceId 4 | import izumi.idealingua.model.common.{ExtendedField, StructureId} 5 | import izumi.idealingua.model.il.ast.typed.Super 6 | 7 | class Struct( 8 | val id: StructureId, 9 | val superclasses: Super, 10 | val unambigious: List[ExtendedField], 11 | val ambigious: List[ExtendedField], 12 | val all: List[ExtendedField], // keeping separatedly to preserve order 13 | ) extends ConstAbstractStruct[ExtendedField] { 14 | override protected def isLocal(f: ExtendedField): Boolean = { 15 | f.defn.definedBy == id 16 | } 17 | 18 | def requiredInterfaces: List[InterfaceId] = { 19 | all 20 | .map(_.defn.definedBy) 21 | .collect { case i: InterfaceId => i } 22 | .distinct 23 | } 24 | } 25 | 26 | final case class PlainStruct(all: List[ExtendedField]) 27 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/types/ScalaField.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.types 2 | 3 | import izumi.idealingua.model.common.ExtendedField 4 | 5 | import scala.collection.compat._ 6 | import scala.meta.{Term, Type} 7 | 8 | final case class ScalaField(name: Term.Name, fieldType: Type, field: ExtendedField) 9 | 10 | object ScalaField { 11 | implicit class ScalaFieldsExt(fields: IterableOnce[ScalaField]) { 12 | def toParams: List[Term.Param] = fields.iterator.map(f => (f.name, f.fieldType)).toParams 13 | 14 | def toNames: List[Term.Name] = fields.iterator.map(_.name).toList 15 | } 16 | 17 | implicit class NamedTypeExt(fields: IterableOnce[(Term.Name, Type)]) { 18 | def toParams: List[Term.Param] = fields.iterator.map(f => (f._1, f._2)).map(toParam).toList 19 | } 20 | 21 | private def toParam(p: (Term.Name, Type)): Term.Param = { 22 | Term.Param(List.empty, p._1, Some(p._2), None) 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/totypescript/TSTContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.totypescript 2 | 3 | import izumi.idealingua.model.publishing.manifests.TypeScriptBuildManifest 4 | import izumi.idealingua.model.typespace.Typespace 5 | import izumi.idealingua.translator.totypescript.extensions.{TypeScriptTranslatorExtension, TypeScriptTranslatorExtensions} 6 | import izumi.idealingua.translator.totypescript.tools.ModuleTools 7 | import izumi.idealingua.translator.totypescript.types.TypeScriptTypeConverter 8 | 9 | class TSTContext( 10 | val typespace: Typespace, 11 | val manifest: TypeScriptBuildManifest, 12 | extensions: Seq[TypeScriptTranslatorExtension], 13 | ) { 14 | final val conv = new TypeScriptTypeConverter() 15 | 16 | final val modules = new ModuleTools() 17 | 18 | final val tools = new TypeScriptTranslationTools() 19 | final val ext = { 20 | new TypeScriptTranslatorExtensions(this, extensions) 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/main/scala/izumi/idealingua/runtime/rpc/http4s/context/HttpContextExtractor.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s.context 2 | 3 | import izumi.idealingua.runtime.rpc.http4s.IRTAuthenticator.AuthContext 4 | import org.http4s.Request 5 | import org.http4s.headers.`X-Forwarded-For` 6 | 7 | trait HttpContextExtractor[RequestCtx] { 8 | def extract[F[_, _]](request: Request[F[Throwable, _]]): RequestCtx 9 | } 10 | 11 | object HttpContextExtractor { 12 | def authContext: HttpContextExtractor[AuthContext] = new HttpContextExtractor[AuthContext] { 13 | override def extract[F[_, _]](request: Request[F[Throwable, _]]): AuthContext = { 14 | val networkAddress = request.headers 15 | .get[`X-Forwarded-For`] 16 | .flatMap(_.values.head.map(_.toInetAddress)) 17 | .orElse(request.remote.map(_.host.toInetAddress)) 18 | val headers = request.headers 19 | AuthContext(headers, networkAddress) 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/structure/Comments.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser.structure 2 | 3 | import fastparse._ 4 | import fastparse.NoWhitespace._ 5 | 6 | trait Comments extends Symbols { 7 | 8 | def MaybeDoc[$: P]: P[Option[String]] = P(DocComment ~ NLC ~ sep.inline).? 9 | 10 | def MultilineComment[$: P]: P0 = P((!"/**" ~ "/*" ~ CommentChunk.rep ~ "*/") | "/**/").rep(1) 11 | 12 | def ShortComment[$: P]: P[Unit] = P("//" ~ (CharsWhile(c => c != '\n' && c != '\r', 0) ~ NLC)) 13 | 14 | protected[structure] def DocComment[$: P]: P[String] = { 15 | P(!"/**/" ~ "/*" ~ (!"*/" ~ "*" ~ DocChunk).rep(1, sep = NLC ~ sep.wss) ~ NLC ~ sep.wss ~ "*/").map { 16 | s => s.mkString("\n") 17 | } 18 | } 19 | 20 | private def DocChunk[$: P]: P[String] = P(CharsWhile(c => c != '\n' && c != '\r').rep.!) 21 | 22 | private def CommentChunk[$: P]: P[Unit] = P(CharsWhile(c => c != '/' && c != '*') | MultilineComment | !"*/" ~ AnyChar) 23 | 24 | } 25 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/models.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | import io.circe.Json 4 | 5 | // addressing 6 | final case class IRTServiceId(value: String) extends AnyVal { 7 | override def toString: String = s"{service:$value}" 8 | } 9 | 10 | final case class IRTMethodName(value: String) extends AnyVal { 11 | override def toString: String = s"{method:$value}" 12 | } 13 | 14 | final case class IRTMethodId(service: IRTServiceId, methodId: IRTMethodName) { 15 | override def toString: String = s"${service.value}.${methodId.value}" 16 | } 17 | 18 | // dtos 19 | 20 | final case class IRTReqBody(value: Product) extends AnyRef 21 | 22 | final case class IRTResBody(value: Product) extends AnyRef 23 | 24 | final case class IRTMuxResponse(body: IRTResBody, method: IRTMethodId) 25 | 26 | final case class IRTMuxRequest(body: IRTReqBody, method: IRTMethodId) 27 | 28 | final case class IRTJsonBody(methodId: IRTMethodId, body: Json) 29 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Authorization/AuthApiKey.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | 4 | namespace IRT.Transport.Authorization { 5 | class AuthApiKey: AuthMethod { 6 | public string ApiKey; 7 | 8 | public AuthApiKey(string apiKey = null) { 9 | ApiKey = apiKey; 10 | } 11 | 12 | public override bool FromValue(string value) { 13 | var lower = value.ToLower(); 14 | if (value.StartsWith("api-key ", StringComparison.Ordinal)) { 15 | ApiKey = value.Substring(8); 16 | return true; 17 | } 18 | 19 | if (value.StartsWith("apikey ", StringComparison.Ordinal)) { 20 | ApiKey = value.Substring(7); 21 | return true; 22 | } 23 | 24 | return false; 25 | } 26 | 27 | public override string ToValue() { 28 | return "Api-Key " + ApiKey; 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/model/publishing/manifests/ProtobufBuildManifest.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.publishing.manifests 2 | 3 | import izumi.idealingua.model.publishing.BuildManifest 4 | import izumi.idealingua.model.publishing.BuildManifest.Common 5 | import izumi.idealingua.model.publishing.manifests.ProtobufBuildManifest.ProtobufRepositoryOptions 6 | 7 | case class ProtobufBuildManifest( 8 | common: Common, 9 | options: Map[String, String], 10 | repository: ProtobufRepositoryOptions, 11 | ) extends BuildManifest 12 | 13 | object ProtobufBuildManifest { 14 | final case class ProtobufRepositoryOptions(repository: String) 15 | 16 | def example: ProtobufBuildManifest = { 17 | val common = BuildManifest.Common.example 18 | ProtobufBuildManifest( 19 | common = common.copy(version = common.version.copy(snapshotQualifier = "SNAPSHOT")), 20 | options = Map.empty, 21 | repository = ProtobufRepositoryOptions("test"), 22 | ) 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Client/IClientTranport.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | using System.Collections.Generic; 4 | using IRT.Transport.Authorization; 5 | 6 | namespace IRT.Transport.Client { 7 | public interface IClientTransport where C: class, IClientTransportContext { 8 | void Send(string service, string method, I payload, ClientTransportCallback callback, C ctx = null); 9 | 10 | void SetAuthorization(AuthMethod method); 11 | AuthMethod GetAuthorization(); 12 | void SetHeaders(Dictionary headers); 13 | Dictionary GetHeaders(); 14 | } 15 | 16 | public interface IClientSocketTransport: IClientTransport where C: class, IClientTransportContext { 17 | bool RegisterBuzzer(IServiceDispatcher buzzer); 18 | bool UnregisterBuzzer(string id); 19 | void SetBuzzerContext(C context); 20 | C GetBuzzerContext(); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/types/runtime/Pkg.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.types.runtime 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | import izumi.idealingua.translator.toscala.types.ScalaTypeConverter 5 | 6 | import scala.annotation.nowarn 7 | import scala.reflect.{ClassTag, classTag} 8 | 9 | @nowarn("msg=constructor modifiers are assumed by synthetic .* method") 10 | final case class Pkg private (pkgParts: Seq[String]) { 11 | final val conv = new ScalaTypeConverter(DomainId(pkgParts.init, pkgParts.last)) 12 | 13 | def within(name: String) = Pkg(pkgParts :+ name) 14 | 15 | def `import`: Import = Import.AllPackage(this) 16 | } 17 | 18 | object Pkg { 19 | 20 | def of[T: ClassTag]: Pkg = { 21 | val className = classTag[T].runtimeClass.getName 22 | val classPkgParts = className.split('.').init 23 | Pkg(classPkgParts.toIndexedSeq) 24 | } 25 | 26 | def language: Pkg = Pkg(Seq("scala", "language")) 27 | } 28 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Logger/ConsoleLogger.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | using IRT; 4 | 5 | namespace IRT.Logger { 6 | public class ConsoleLogger: ILogger { 7 | private LogLevel level; 8 | 9 | public ConsoleLogger(LogLevel level) { 10 | this.level = level; 11 | } 12 | 13 | public void Logf(LogLevel level, string format, params object[] args) { 14 | if (this.level > level) { 15 | return; 16 | } 17 | 18 | var prefix = "[ " + level.ToString() + ", " + DateTime.Now.ToString() + " ]: "; 19 | if (level == LogLevel.Error) { 20 | Console.WriteLine("******************** ERROR ********************\n"); 21 | Console.WriteLine(prefix + format, args); 22 | Console.WriteLine("\n***********************************************"); 23 | } else { 24 | Console.WriteLine(prefix + format, args); 25 | } 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /.mobala/steps/spec/cs_spec.sh: -------------------------------------------------------------------------------- 1 | Describe 'CS transpiler' 2 | Include ./.mobala/steps/lib/builders.sh 3 | 4 | setup() { 5 | export refsdir="$PWD/idealingua-v1/idealingua-v1-test-defs/src/main/resources/refs/csharp" 6 | export refs="$(find "$refsdir" -name "*.dll" -exec echo "/reference:{}" \; | xargs -0 | tr '\n' ' ')" 7 | } 8 | 9 | BeforeAll 'setup' 10 | 11 | Parameters:dynamic 12 | while read line; do 13 | %data "$line" 14 | done <<< "$(find ./idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs -maxdepth 1 -mindepth 1 -type d)" 15 | End 16 | 17 | It "builds CS MSBuild project in $1" 18 | When call test_cs_msbuild_prj "$1" 19 | The status should be success 20 | The output should match pattern '*' 21 | The stderr should match pattern '*' 22 | End 23 | 24 | It "builds CS Nuget project in $1" 25 | When call test_cs_plain_prj "$1" 26 | The status should be success 27 | The output should match pattern '*' 28 | The stderr should match pattern '*' 29 | End 30 | End 31 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/npmjs/publish.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -ex 4 | 5 | export THISDIR="$( cd "$(dirname "$0")" ; pwd -P )" 6 | 7 | pushd . 8 | cd $THISDIR 9 | 10 | pkgFile='package.json' 11 | pkgName=$(cat package.json | node -pe 'JSON.parse(fs.readFileSync(0)).name') 12 | pkgPath='dist' 13 | 14 | cp -R ../main/resources/runtime/typescript/irt . 15 | npm install 16 | 17 | tsc -p ./tsconfig.json 18 | tsc -p ./tsconfig.es.json 19 | 20 | cp package.json ${pkgPath}/ 21 | node -p "JSON.stringify({...require(path.resolve(__dirname, 'package.json')), name: '${pkgName}-es'}, null, 2)" > ${pkgPath}-es/package.json 22 | 23 | npm install json 24 | ./node_modules/json/lib/json.js -I -f ${pkgPath}/package.json -e "this.version=\"${PROJECT_VERSION}\"" 25 | ./node_modules/json/lib/json.js -I -f ${pkgPath}-es/package.json -e "this.version=\"${PROJECT_VERSION}\"" 26 | 27 | ( cd ${pkgPath} && npm publish --access public || exit 1 ) 28 | ( cd ${pkgPath}-es && npm publish --access public || exit 1 ) 29 | 30 | popd 31 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/DefParsers.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser 2 | 3 | import izumi.idealingua.model.il.ast.raw.domains.ParsedDomain 4 | import izumi.idealingua.model.il.ast.raw.models.{ModelMember, ParsedModel} 5 | import fastparse.NoWhitespace._ 6 | import fastparse._ 7 | 8 | class DefParsers(context: IDLParserContext) { 9 | 10 | import izumi.idealingua.il.parser.structure.sep._ 11 | import context._ 12 | 13 | protected[parser] def modelDef[$: P]: P[ParsedModel] = P(any ~ defMember.anyMember.rep(sep = any) ~ any ~ End).map { 14 | defs => 15 | val tlds = defs.collect { case ModelMember.MMTopLevelDefn(defn) => defn } 16 | val inclusions = defs.collect { case ModelMember.MMInclusion(inc) => inc } 17 | 18 | ParsedModel(tlds, inclusions) 19 | } 20 | 21 | protected[parser] def fullDomainDef[$: P]: P[ParsedDomain] = P(Start ~ any ~ defDomain.decl ~ modelDef).map { 22 | case (decl, defs) => 23 | ParsedDomain(decl, defs) 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/ConstValue.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.common.TypeId 4 | 5 | sealed trait ConstValue 6 | 7 | object ConstValue { 8 | 9 | final case class CInt(value: Int) extends ConstValue 10 | final case class CLong(value: Long) extends ConstValue 11 | final case class CFloat(value: Double) extends ConstValue 12 | final case class CString(value: String) extends ConstValue 13 | final case class CBool(value: Boolean) extends ConstValue 14 | final case class CMap(value: Map[String, ConstValue]) extends ConstValue 15 | final case class CList(value: List[ConstValue]) extends ConstValue 16 | 17 | sealed trait Typed extends ConstValue { 18 | def typeId: TypeId 19 | } 20 | 21 | final case class CTypedList(typeId: TypeId, value: CList) extends Typed 22 | final case class CTypedObject(typeId: TypeId, value: CMap) extends Typed 23 | final case class CTyped(typeId: TypeId, value: ConstValue) extends Typed 24 | 25 | } 26 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/DefMethod.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.common.TypeId 4 | 5 | sealed trait DefMethod { 6 | def meta: NodeMeta 7 | } 8 | 9 | object DefMethod { 10 | 11 | sealed trait Output 12 | 13 | object Output { 14 | sealed trait NonAlternativeOutput extends Output 15 | 16 | final case class Void() extends NonAlternativeOutput 17 | 18 | final case class Singular(typeId: TypeId) extends NonAlternativeOutput 19 | 20 | final case class Struct(struct: SimpleStructure) extends NonAlternativeOutput 21 | 22 | final case class Algebraic(alternatives: List[AdtMember]) extends NonAlternativeOutput 23 | 24 | final case class Alternative(success: NonAlternativeOutput, failure: NonAlternativeOutput) extends Output 25 | } 26 | 27 | final case class Signature(input: SimpleStructure, output: Output) 28 | 29 | final case class RPCMethod(name: String, signature: Signature, meta: NodeMeta) extends DefMethod 30 | } 31 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/auth/auth.basic.ts: -------------------------------------------------------------------------------- 1 | import { AuthMethod } from './auth.method'; 2 | 3 | export class AuthBasic extends AuthMethod { 4 | public user: string; 5 | public pass: string; 6 | 7 | constructor(user: string = undefined, pass: string = undefined) { 8 | super(); 9 | this.user = user; 10 | this.pass = pass ? btoa(pass) : undefined; 11 | } 12 | 13 | public getPass(): string { 14 | return atob(this.pass); 15 | } 16 | 17 | public fromValue(value: string): Error { 18 | const basicPieces = value.split(':'); 19 | if (basicPieces.length !== 2) { 20 | return new Error('basic authorization update expects "user:pass" format, got ' + value); 21 | } 22 | 23 | this.user = basicPieces[0]; 24 | this.pass = basicPieces[1]; 25 | return undefined; 26 | } 27 | 28 | public toValue(): string { 29 | return 'Basic ' + this.user + ':' + this.pass; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/structure/Separators.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser.structure 2 | 3 | import fastparse.NoWhitespace._ 4 | import fastparse._ 5 | 6 | trait Separators extends Comments { 7 | private def ws[$: P]: P[Unit] = P(" " | "\t") 8 | 9 | def wss[$: P]: P[Unit] = P(ws.rep) 10 | 11 | private def WsComment[$: P]: P[Unit] = P(wss ~ MultilineComment ~ wss) 12 | 13 | private def SepLineBase[$: P]: P[Unit] = P(NLC | (WsComment ~ NLC | (wss ~ ShortComment))) 14 | 15 | def inline[$: P]: P[Unit] = P(WsComment | wss) 16 | 17 | def any[$: P]: P[Unit] = P(wss ~ (WsComment | SepLineBase).rep ~ wss) 18 | 19 | def sepStruct[$: P]: P[Unit] = P(any ~ (";" | "," | SepLineBase | any) ~ any) 20 | 21 | def sepEnum[$: P]: P[Unit] = P((ws.rep(1) | NLC | WsComment | (wss ~ ShortComment)).rep(1)) 22 | 23 | def sepAdt[$: P]: P[Unit] = P(sepEnum) 24 | 25 | def sepEnumFreeForm[$: P]: P[Unit] = P(any ~ ("|" | ";" | ",") ~ any) 26 | 27 | def sepAdtFreeForm[$: P]: P[Unit] = P(sepEnumFreeForm) 28 | 29 | } 30 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/ModelLoaderImpl.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | import izumi.idealingua.model.loader.UnresolvedDomains 4 | 5 | class ModelLoaderImpl( 6 | enumerator: FilesystemEnumerator, 7 | parser: ModelParser, 8 | modelExt: String, 9 | domainExt: String, 10 | overlayExt: String, 11 | ) extends ModelLoader { 12 | def load(): UnresolvedDomains = { 13 | val files = enumerator.enumerate() 14 | val domainFiles = files.filter(_._1.name.endsWith(domainExt)) 15 | val modelFiles = files.filter(_._1.name.endsWith(modelExt)) 16 | val modelOverlayFiles = files.filter(_._1.name.endsWith(overlayExt)).map { 17 | case (k, v) => 18 | k.rename(n => n.replace(overlayExt, "")).move(p => ModelLoader.overlayVirtualDir +: p) -> v 19 | } 20 | 21 | val domains = parser.parseDomains(domainFiles) 22 | val models = parser.parseModels(modelFiles) 23 | val overlays = parser.parseModels(modelOverlayFiles) 24 | 25 | UnresolvedDomains(domains, models, overlays) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/Server/SystemContext.cs: -------------------------------------------------------------------------------- 1 | 2 | using IRT.Transport.Authorization; 3 | 4 | namespace IRT.Transport.Server { 5 | public class SystemContext { 6 | public AuthMethod Auth; 7 | 8 | public bool UpdateAuth(string value) { 9 | if (string.IsNullOrEmpty(value)) { 10 | Auth = null; 11 | return true; 12 | } 13 | 14 | if (value.StartsWith("Bearer ")) { 15 | Auth = new AuthToken(); 16 | } else 17 | if (value.StartsWith("Basic ")) { 18 | Auth = new AuthBasic(); 19 | } else { 20 | var lower = value.ToLowerInvariant(); 21 | if (lower.StartsWith("api-key") || lower.StartsWith("apikey")) { 22 | Auth = new AuthApiKey(); 23 | } else { 24 | Auth = new AuthCustom(); 25 | } 26 | } 27 | 28 | return Auth.FromValue(value); 29 | } 30 | } 31 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawMethod.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.AbstractIndefiniteId 4 | 5 | sealed trait RawMethod { 6 | def meta: RawNodeMeta 7 | } 8 | 9 | object RawMethod { 10 | 11 | sealed trait Output 12 | 13 | object Output { 14 | 15 | sealed trait NonAlternativeOutput extends Output 16 | 17 | final case class Struct(input: RawSimpleStructure) extends NonAlternativeOutput 18 | 19 | final case class Algebraic(alternatives: List[RawAdt.Member]) extends NonAlternativeOutput 20 | 21 | final case class Singular(typeId: AbstractIndefiniteId) extends NonAlternativeOutput 22 | 23 | final case class Void() extends NonAlternativeOutput 24 | 25 | final case class Alternative(success: NonAlternativeOutput, failure: NonAlternativeOutput) extends Output 26 | 27 | } 28 | 29 | final case class Signature(input: RawSimpleStructure, output: Output) 30 | 31 | final case class RPCMethod(name: String, signature: Signature, meta: RawNodeMeta) extends RawMethod 32 | 33 | } 34 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/transport.ts: -------------------------------------------------------------------------------- 1 | 2 | import { AuthMethod } from './auth'; 3 | import { ServiceDispatcher } from '../dispatcher'; 4 | 5 | export interface IncomingData { 6 | serialize(): any; 7 | } 8 | 9 | export type OutgoingData = any; 10 | export type TransportHeaders = {[key: string]: string}; 11 | 12 | export interface ClientTransport { 13 | send(service: string, method: string, data: IncomingData): Promise 14 | setAuthorization(method: AuthMethod | undefined): void 15 | getAuthorization(): AuthMethod | undefined 16 | setHeaders(headers: TransportHeaders | undefined): void 17 | getHeaders(): TransportHeaders 18 | } 19 | 20 | export interface ClientSocketTransport extends ClientTransport { 21 | setContext(context: C): void 22 | getContext(): C 23 | registerBuzzer(buzzer: ServiceDispatcher): boolean 24 | unregisterBuzzer(id: string): boolean 25 | } 26 | 27 | export interface ServerSocketTransport { 28 | send(service: string, method: string, data: IncomingData): Promise 29 | } -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawVal.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.AbstractIndefiniteId 4 | 5 | sealed trait RawVal 6 | 7 | object RawVal { 8 | 9 | sealed trait RawValScalar extends RawVal 10 | 11 | final case class CInt(value: Int) extends RawValScalar 12 | 13 | final case class CLong(value: Long) extends RawValScalar 14 | 15 | final case class CFloat(value: Double) extends RawValScalar 16 | 17 | final case class CString(value: String) extends RawValScalar 18 | 19 | final case class CBool(value: Boolean) extends RawValScalar 20 | 21 | final case class CMap(value: Map[String, RawVal]) extends RawVal 22 | 23 | final case class CList(value: List[RawVal]) extends RawVal 24 | 25 | final case class CTyped(typeId: AbstractIndefiniteId, value: RawVal) extends RawVal 26 | 27 | final case class CTypedList(typeId: AbstractIndefiniteId, value: List[RawVal]) extends RawVal 28 | 29 | final case class CTypedObject(typeId: AbstractIndefiniteId, value: Map[String, RawVal]) extends RawVal 30 | 31 | } 32 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/IDLLanguage.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator 2 | 3 | sealed trait IDLLanguage 4 | 5 | object IDLLanguage { 6 | case object Scala extends IDLLanguage { 7 | override val toString: String = "scala" 8 | } 9 | 10 | case object Go extends IDLLanguage { 11 | override val toString: String = "go" 12 | } 13 | 14 | case object Typescript extends IDLLanguage { 15 | override val toString: String = "typescript" 16 | } 17 | 18 | case object CSharp extends IDLLanguage { 19 | override val toString: String = "csharp" 20 | } 21 | 22 | case object Protobuf extends IDLLanguage { 23 | override val toString: String = "protobuf" 24 | } 25 | 26 | def parse(s: String): IDLLanguage = { 27 | (s.trim.toLowerCase: @unchecked) match { 28 | case Scala.toString => 29 | Scala 30 | case Go.toString => 31 | Go 32 | case Typescript.toString => 33 | Typescript 34 | case CSharp.toString => 35 | CSharp 36 | case Protobuf.toString => 37 | Protobuf 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /.mobala/steps/run-flake-refresh.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -euo pipefail 4 | 5 | function do_update() { 6 | escaped="${2//[\/&]/\\&}" 7 | 8 | sed -i -E \ 9 | -e "s/version\s*=\s*\"([a-z0-9-]\.?)+\";/version = \"$1\";/g" \ 10 | -e "s/depsSha256\s*=\s*\"([^\"])*\";/depsSha256 = \"$escaped\";/g" \ 11 | $3 12 | } 13 | 14 | 15 | function run-flake-refresh() { 16 | if [[ "$DO_FLAKE_VALIDATE" == 1 ]]; then 17 | hash_before=$(cat flake.nix| md5sum) 18 | fi 19 | 20 | do_update "0.0.0" "" ./flake.nix 21 | 22 | PKG_VERSION=$(cat version.sbt | sed -r 's/.*\"(.*)\".**/\1/' | sed -E "s/-SNAPSHOT//") 23 | 24 | set +o pipefail 25 | PROPER_HASH=$(nix build --print-build-logs 2>&1 . | grep "got:" | awk '{print $2}') 26 | set -o pipefail 27 | 28 | do_update "$PKG_VERSION" "$PROPER_HASH" ./flake.nix 29 | 30 | if [[ "$DO_FLAKE_VALIDATE" == 1 ]]; then 31 | hash_after=$(cat flake.nix| md5sum) 32 | 33 | if [[ "$hash_before" != "$hash_after" ]]; then 34 | echo "flake.nix is not up to date, run ./run --nix :flake-refresh" 35 | exit 1 36 | fi 37 | fi 38 | 39 | git add . || true 40 | } 41 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/togolang/types/GoLangImportRecord.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.togolang.types 2 | 3 | import izumi.idealingua.model.common.Package 4 | import izumi.idealingua.model.common.TypeId 5 | 6 | final case class GoLangImportRecord(id: TypeId, importName: String, pkg: Package) { 7 | def renderImport(prefix: String): String = { 8 | if (pkg.isEmpty) { 9 | return "" 10 | } 11 | 12 | val directImports = Seq( 13 | "time", 14 | "regexp", 15 | "encoding/json", 16 | ) 17 | 18 | val pkgStr = pkg.mkString("/") 19 | 20 | val pre = 21 | if (prefix.nonEmpty && !directImports.contains(pkgStr)) 22 | if (!prefix.endsWith("/") && !prefix.endsWith("\\")) prefix + "/" else prefix 23 | else 24 | "" 25 | 26 | (if (importName.length == 0 || pkg.last == importName) "" else s"$importName ") + 27 | "\"" + pre + pkgStr + "\"" 28 | } 29 | } 30 | 31 | object GoLangImportRecord { 32 | def apply(id: TypeId, importName: String, pkg: Package): GoLangImportRecord = 33 | new GoLangImportRecord(id, importName, pkg) 34 | } 35 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/raw/defns/RawEnumMember.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.raw.defns 2 | 3 | import izumi.idealingua.model.common.TypeId 4 | 5 | case class RawEnumMember(value: String, associated: Option[RawVal], meta: RawNodeMeta) { 6 | override def toString: String = value 7 | } 8 | 9 | case class RawEnum(parents: List[TypeId.EnumId], members: List[RawEnumMember], removed: List[String]) 10 | 11 | object RawEnum { 12 | sealed trait EnumOp 13 | 14 | object EnumOp { 15 | 16 | final case class Extend(tpe: TypeId.EnumId) extends EnumOp 17 | 18 | final case class AddMember(field: RawEnumMember) extends EnumOp 19 | 20 | final case class RemoveMember(field: String) extends EnumOp 21 | 22 | } 23 | 24 | final case class Aux(structure: RawEnum) 25 | 26 | object Aux { 27 | def apply(v: Seq[EnumOp]): Aux = { 28 | import EnumOp._ 29 | Aux( 30 | RawEnum( 31 | v.collect { case Extend(i) => i }.toList, 32 | v.collect { case AddMember(i) => i }.toList, 33 | v.collect { case RemoveMember(i) => i }.toList, 34 | ) 35 | ) 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/resources/defs/main-tests/source/idltest/anyvals.domain: -------------------------------------------------------------------------------- 1 | domain idltest.anyvals 2 | 3 | id RecordId { 4 | value: uid 5 | } 6 | 7 | mixin WithRecordId { 8 | id: RecordId 9 | } 10 | 11 | mixin UserData { 12 | id: WithRecordId 13 | } 14 | 15 | 16 | // 17 | data SimpleAnyValRecord { 18 | _: str 19 | } 20 | 21 | 22 | // ANYVAL:ERASURE: primary test case 23 | data Test00Data1AnyVal { 24 | _: str 25 | } 26 | 27 | data Test00Data2AnyVal { 28 | + Test00Data1AnyVal 29 | someInt: i08 30 | } 31 | 32 | 33 | // 34 | mixin Test01MixinAnyVal { 35 | _: str 36 | } 37 | 38 | data Test01DataAnyVal1 { 39 | & Test01MixinAnyVal 40 | someInt: i08 41 | } 42 | 43 | data Test01DataAnyVal2 { 44 | + Test01MixinAnyVal 45 | someInt: i08 46 | } 47 | 48 | // 49 | data Test02DtoAnyVal { 50 | _: str 51 | } 52 | 53 | data Test02UserAnyVal { 54 | _: Test02DtoAnyVal 55 | _: i08 56 | } 57 | 58 | // direct cyclic usage is disabled 59 | // https://github.com/7mind/izumi/issues/334 60 | /* 61 | data Cyclic00 { 62 | _: Cyclic00 63 | } 64 | 65 | data Cyclic01 { 66 | _: Cyclic02 67 | } 68 | 69 | mixin Cyclic02 { 70 | _: Cyclic01 71 | } 72 | */ 73 | 74 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/DomainDefinition.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | import izumi.idealingua.model.il.ast.IDLPostTyper 5 | import izumi.idealingua.model.il.ast.raw.domains.Import 6 | import izumi.idealingua.model.loader.FSPath 7 | 8 | case class Inclusion(include: String) 9 | 10 | final case class DomainMetadata(origin: FSPath, directInclusions: Seq[Inclusion], directImports: Seq[Import], meta: NodeMeta) 11 | 12 | final case class DomainDefinition( 13 | id: DomainId, 14 | meta: DomainMetadata, 15 | types: Seq[TypeDef], 16 | services: Seq[Service], 17 | buzzers: Seq[Buzzer], 18 | streams: Seq[Streams], 19 | referenced: Map[DomainId, IDLPostTyper], // there may be a referential loop 20 | ) { 21 | def nonEmpty: Boolean = types.nonEmpty || services.nonEmpty || buzzers.nonEmpty || streams.nonEmpty 22 | 23 | override def hashCode(): Int = id.hashCode() 24 | 25 | override def equals(obj: Any): Boolean = { 26 | obj match { 27 | case d: DomainDefinition => 28 | id == d.id 29 | case _ => 30 | false 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/DomainMeshResolvedMutable.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | import izumi.idealingua.model.common.DomainId 4 | import izumi.idealingua.model.il.ast.raw.defns.{RawNodeMeta, RawTopLevelDefn} 5 | import izumi.idealingua.model.il.ast.raw.domains.{DomainMeshResolved, Import} 6 | import izumi.idealingua.model.il.ast.raw.models.Inclusion 7 | import izumi.idealingua.model.loader.FSPath 8 | 9 | import scala.annotation.nowarn 10 | import scala.collection.mutable 11 | 12 | @nowarn("msg=Unused import") 13 | private[loader] class DomainMeshResolvedMutable( 14 | override val id: DomainId, 15 | override val members: Seq[RawTopLevelDefn], 16 | override val origin: FSPath, 17 | override val directInclusions: Seq[Inclusion], 18 | override val imports: Seq[Import], 19 | override val meta: RawNodeMeta, 20 | refContext: mutable.Map[DomainId, DomainMeshResolved], 21 | requiredRefs: Set[DomainId], 22 | ) extends DomainMeshResolved { 23 | import scala.collection.compat.* 24 | 25 | override def referenced: Map[DomainId, DomainMeshResolved] = { 26 | refContext.view.filterKeys(requiredRefs.contains).toMap 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/DefDomain.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser 2 | 3 | import izumi.idealingua.il.parser.structure._ 4 | import izumi.idealingua.model.common.DomainId 5 | import izumi.idealingua.model.il.ast.raw.domains 6 | import izumi.idealingua.model.il.ast.raw.domains.{DomainHeader, Import} 7 | import fastparse.NoWhitespace._ 8 | import fastparse._ 9 | 10 | class DefDomain(context: IDLParserContext) 11 | extends Identifiers 12 | with Aggregates { 13 | 14 | import context._ 15 | 16 | def domainBlock[$: P]: P[DomainId] = P(kw.domain ~/ domainId) 17 | 18 | def importBlock[$: P]: P[Import] = kw(kw.`import`, domainId ~ ("." ~ inline ~ enclosed(defStructure.imports(sep.sepStruct) ~ sepStruct.?)).?) 19 | .map { 20 | case (id, names) => 21 | names match { 22 | case Some(nn) => 23 | domains.Import(id, nn.toSet) 24 | case None => 25 | Import(id, Set.empty) 26 | } 27 | } 28 | 29 | def decl[$: P]: P[DomainHeader] = P(metaAgg.withMeta(domainBlock ~ any ~ importBlock.rep(sep = any))).map { 30 | case (meta, (id, imports)) => 31 | DomainHeader(id, imports, meta) 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/structure/MetaAggregates.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser.structure 2 | 3 | import izumi.idealingua.il.parser.IDLParserContext 4 | import izumi.idealingua.model.il.ast.raw.defns.RawNodeMeta 5 | import izumi.idealingua.model.il.ast.raw.typeid.ParsedId 6 | import fastparse.NoWhitespace._ 7 | import fastparse._ 8 | 9 | class MetaAggregates(context: IDLParserContext) { 10 | import aggregates._ 11 | 12 | def withMeta[T](defparser: => P[T])(implicit v: P[?]): P[(RawNodeMeta, T)] = { 13 | P(MaybeDoc ~ context.defConst.defAnnos ~ context.defPositions.positioned(defparser)).map { 14 | case (doc, annos, (pos, r)) => 15 | (RawNodeMeta(doc, annos, pos), r) 16 | } 17 | } 18 | 19 | def cstarting[T](keyword: => P[Unit], defparser: => P[T])(implicit v: P[?]): P[(RawNodeMeta, ParsedId, T)] = { 20 | withMeta(starting(keyword, defparser)).map { 21 | case (m, (i, t)) => (m, i, t) 22 | } 23 | } 24 | 25 | def cblock[T](keyword: => P[Unit], defparser: => P[T])(implicit v: P[?]): P[(RawNodeMeta, ParsedId, T)] = { 26 | withMeta(block(keyword, defparser)).map { 27 | case (m, (i, t)) => (m, i, t) 28 | } 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RStructure.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.il.ast.typed.{Structure, Structures, Tuple} 5 | 6 | class RStructure(context: IDLRenderingContext) extends Renderable[Structure] { 7 | import context._ 8 | 9 | override def render(structure: Structure): String = { 10 | Seq( 11 | renderComposite(structure.superclasses.interfaces, "& "), 12 | renderComposite(structure.superclasses.concepts, "+ "), 13 | renderComposite(structure.superclasses.removedConcepts, "- "), 14 | renderAggregate(structure.fields, ""), 15 | renderAggregate(structure.removedFields, "- "), 16 | ) 17 | .filterNot(_.isEmpty) 18 | .mkString("\n") 19 | } 20 | 21 | private def renderComposite(aggregate: Structures, prefix: String): String = { 22 | aggregate 23 | .map(_.render()) 24 | .map(t => s"$prefix$t") 25 | .mkString("\n") 26 | } 27 | 28 | private def renderAggregate(aggregate: Tuple, prefix: String): String = { 29 | aggregate 30 | .map(_.render()) 31 | .map(t => s"$prefix$t") 32 | .mkString("\n") 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala/izumi/idealingua/runtime/rpc/IRTTransportException.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc 2 | 3 | abstract class IRTTransportException(message: String, cause: Option[Throwable]) extends RuntimeException(message, cause.orNull) 4 | 5 | class IRTUnparseableDataException(message: String, cause: Option[Throwable] = None) extends IRTTransportException(message, cause) 6 | 7 | class IRTDecodingException(message: String, cause: Option[Throwable] = None) extends IRTTransportException(message, cause) 8 | 9 | class IRTTypeMismatchException(message: String, val v: Any, cause: Option[Throwable] = None) extends IRTTransportException(message, cause) 10 | 11 | class IRTMissingHandlerException(message: String, val v: Any, cause: Option[Throwable] = None) extends IRTTransportException(message, cause) 12 | 13 | class IRTLimitReachedException(message: String, cause: Option[Throwable] = None) extends IRTTransportException(message, cause) 14 | 15 | class IRTUnathorizedRequestContextException(message: String, cause: Option[Throwable] = None) extends IRTTransportException(message, cause) 16 | 17 | class IRTGenericFailure(message: String, cause: Option[Throwable] = None) extends IRTTransportException(message, cause) 18 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/verification/rules/AdtMembersRule.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.verification.rules 2 | 3 | import izumi.idealingua.model.common.Builtin 4 | import izumi.idealingua.model.common.TypeId.AliasId 5 | import izumi.idealingua.model.problems.{IDLDiagnostics, TypespaceError} 6 | import izumi.idealingua.model.il.ast.typed.AdtMember 7 | import izumi.idealingua.model.il.ast.typed.TypeDef.Adt 8 | import izumi.idealingua.model.typespace.Typespace 9 | import izumi.idealingua.model.typespace.verification.VerificationRule 10 | 11 | object AdtMembersRule extends VerificationRule { 12 | override def verify(ts: Typespace): IDLDiagnostics = IDLDiagnostics { 13 | ts.domain.types.flatMap { 14 | case t: Adt => 15 | val builtins = t.alternatives.collect { 16 | case m @ AdtMember(_: Builtin, _, _) => 17 | m 18 | case m @ AdtMember(a: AliasId, _, _) if ts.dealias(a).isInstanceOf[Builtin] => 19 | m 20 | } 21 | if (builtins.nonEmpty) { 22 | Seq(TypespaceError.PrimitiveAdtMember(t.id, builtins)) 23 | } else { 24 | Seq.empty 25 | } 26 | case _ => 27 | Seq.empty 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/main/scala/izumi/idealingua/runtime/rpc/http4s/ws/WsSessionListener.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s.ws 2 | 3 | import izumi.functional.bio.{Applicative2, F} 4 | 5 | trait WsSessionListener[F[_, _], -RequestCtx, -WsCtx] { 6 | def onSessionOpened(sessionId: WsSessionId, reqCtx: RequestCtx, wsCtx: WsCtx): F[Throwable, Unit] 7 | def onSessionUpdated(sessionId: WsSessionId, reqCtx: RequestCtx, prevStx: WsCtx, newCtx: WsCtx): F[Throwable, Unit] 8 | def onSessionClosed(sessionId: WsSessionId, wsCtx: WsCtx): F[Throwable, Unit] 9 | } 10 | 11 | object WsSessionListener { 12 | type Global[F[_, _]] = WsSessionListener[F, Any, Any] 13 | 14 | def empty[F[+_, +_]: Applicative2, RequestCtx, WsCtx]: WsSessionListener[F, RequestCtx, WsCtx] = new WsSessionListener[F, RequestCtx, WsCtx] { 15 | override def onSessionOpened(sessionId: WsSessionId, reqCtx: RequestCtx, wsCtx: WsCtx): F[Throwable, Unit] = F.unit 16 | override def onSessionUpdated(sessionId: WsSessionId, reqCtx: RequestCtx, prevStx: WsCtx, newCtx: WsCtx): F[Throwable, Unit] = F.unit 17 | override def onSessionClosed(sessionId: WsSessionId, wsCtx: WsCtx): F[Throwable, Unit] = F.unit 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/totypescript/layout/TypescriptNamingConvention.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.totypescript.layout 2 | 3 | import izumi.idealingua.model.output.ModuleId 4 | import izumi.idealingua.model.publishing.manifests.TypeScriptBuildManifest 5 | import izumi.idealingua.translator.BaseNamingConvention 6 | 7 | class TypescriptNamingConvention(manifest: TypeScriptBuildManifest) { 8 | private val naming = new BaseNamingConvention(manifest.yarn.projectNaming) 9 | 10 | def toDirName(parts: Seq[String]): String = { 11 | toDirParts(parts).mkString("-") 12 | } 13 | 14 | private def toDirParts(parts: Seq[String]): Seq[String] = { 15 | naming.baseProjectId(parts).map(_.toLowerCase) 16 | } 17 | 18 | def toScopedId(parts: Seq[String]): String = { 19 | s"${manifest.yarn.scope}/${toDirName(parts)}" 20 | } 21 | 22 | def makeName(m: ModuleId): String = { 23 | toDirName(m.path) 24 | } 25 | 26 | def specialId(what: String): String = { 27 | val parts = Seq(what) ++ toDirParts(Seq.empty) 28 | s"${manifest.yarn.scope}/${parts.mkString("-")}" 29 | } 30 | 31 | def irtDependency: String = specialId("irt") 32 | 33 | def bundleId: String = specialId("bundle") 34 | 35 | } 36 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-go/src/main/resources/runtime/go/irt/marshaller.go: -------------------------------------------------------------------------------- 1 | package irt 2 | 3 | import ( 4 | "encoding/json" 5 | "fmt" 6 | ) 7 | 8 | type Marshaller interface { 9 | Marshal(data interface{}) ([]byte, error) 10 | Unmarshal(data []byte, model interface{}) error 11 | } 12 | 13 | type JSONMarshaller struct { 14 | pretty bool 15 | } 16 | 17 | func NewJSONMarshaller(pretty bool) *JSONMarshaller { 18 | return &JSONMarshaller{ 19 | pretty: pretty, 20 | } 21 | } 22 | 23 | func (m *JSONMarshaller) Marshal(data interface{}) ([]byte, error) { 24 | if m.pretty { 25 | return json.MarshalIndent(data, "", " ") 26 | } else { 27 | return json.Marshal(data) 28 | } 29 | } 30 | 31 | func (m *JSONMarshaller) Unmarshal(data []byte, model interface{}) error { 32 | return json.Unmarshal(data, model) 33 | } 34 | 35 | type BinaryMarshaller struct { 36 | } 37 | 38 | func NewBinaryMarshaller() *BinaryMarshaller { 39 | return &BinaryMarshaller{} 40 | } 41 | 42 | func (m *BinaryMarshaller) Marshal(data interface{}) ([]byte, error) { 43 | return nil, fmt.Errorf("binary marshaller is not implemented") 44 | } 45 | 46 | func (m *BinaryMarshaller) Unmarshal(data []byte, model interface{}) error { 47 | return fmt.Errorf("binary marshaller is not implemented") 48 | } 49 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toprotobuf/PBTContext.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toprotobuf 2 | 3 | import izumi.idealingua.model.typespace.Typespace 4 | import izumi.idealingua.translator.toprotobuf.tools.ModuleTools 5 | import izumi.idealingua.translator.toprotobuf.extensions.{ProtobufTranslatorExtension, ProtobufTranslatorExtensions} 6 | import izumi.idealingua.translator.toprotobuf.types.ProtobufTypeConverter 7 | 8 | class PBTContext( 9 | val typespace: Typespace, 10 | extensions: Seq[ProtobufTranslatorExtension], 11 | options: Map[String, String], 12 | ) { 13 | final val modules = new ModuleTools(options) 14 | final val conv = new ProtobufTypeConverter(typespace.domain.id) 15 | final val ext = { 16 | new ProtobufTranslatorExtensions(this, extensions) 17 | } 18 | 19 | final val interfaceRenderer = new InterfaceRenderer(this) 20 | final val compositeRenderer = new CompositeRenderer(this) 21 | final val enumRenderer = new EnumRenderer(this) 22 | final val adtRenderer = new AdtRenderer(this) 23 | final val identifierRenderer = new IdentifierRenderer(this) 24 | final val aliasRenderer = new AliasRenderer(this) 25 | final val serviceRenderer = new ServiceRenderer(this) 26 | } 27 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Redistribution and use in source and binary forms, with or without 2 | modification, are permitted provided that the following conditions are met: 3 | 4 | * Redistributions of source code must retain the above copyright notice, this 5 | list of conditions and the following disclaimer. 6 | 7 | * Redistributions in binary form must reproduce the above copyright notice, 8 | this list of conditions and the following disclaimer in the documentation 9 | and/or other materials provided with the distribution. 10 | 11 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 12 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 13 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 14 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 15 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 16 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 17 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 18 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 19 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 20 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/model/JavaType.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model 2 | 3 | import izumi.idealingua.model 4 | import izumi.idealingua.model.common.{DomainId, Package, PackageTools} 5 | 6 | import scala.reflect.{ClassTag, classTag} 7 | 8 | final case class JavaType(pkg: Package, name: String, parameters: Seq[String] = Seq.empty) { 9 | def parent: JavaType = { 10 | JavaType(pkg.init, pkg.last, Seq.empty) 11 | } 12 | 13 | def withRoot: JavaType = { 14 | if (pkg.nonEmpty) { 15 | JavaType("_root_" +: pkg, name, parameters) 16 | } else { 17 | // TODO: this is just one more unsafe workaround 18 | JavaType(Seq.empty, name, parameters) 19 | } 20 | } 21 | 22 | def minimize(domainId: DomainId): JavaType = { 23 | val minimalPackageRef = PackageTools.minimize(pkg, domainId.toPackage) 24 | JavaType(minimalPackageRef, name, parameters) 25 | } 26 | } 27 | 28 | object JavaType { 29 | def get[T: ClassTag]: JavaType = { 30 | val clazz = classTag[T].runtimeClass.getName 31 | assert(clazz.nonEmpty) 32 | val parts = clazz.split('.').toSeq 33 | model.JavaType(parts.init, parts.last, Seq.empty) 34 | } 35 | 36 | def apply(typeId: DomainId): JavaType = new JavaType(typeId.pkg, typeId.id, Seq.empty) 37 | } 38 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/loader/ModelParserImpl.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.loader 2 | 3 | import izumi.idealingua.il.parser.{IDLParser, IDLParserContext} 4 | import izumi.idealingua.model.loader._ 5 | import fastparse._ 6 | 7 | class ModelParserImpl() extends ModelParser { 8 | def parseModels(files: Map[FSPath, String]): ParsedModels = ParsedModels { 9 | files.map { 10 | case (file, content) => 11 | file -> new IDLParser(IDLParserContext(file)).parseModel(content) 12 | }.toSeq.map { 13 | case (p, Parsed.Success(value, _)) => 14 | ModelParsingResult.Success(p, value) 15 | 16 | case (p, f: Parsed.Failure) => 17 | ModelParsingResult.Failure(p, s"Failed to parse model $p: ${f.msg}") 18 | 19 | } 20 | } 21 | 22 | def parseDomains(files: Map[FSPath, String]): ParsedDomains = ParsedDomains { 23 | files.map { 24 | case (file, content) => 25 | file -> new IDLParser(IDLParserContext(file)).parseDomain(content) 26 | }.toSeq.map { 27 | case (p, Parsed.Success(value, _)) => 28 | DomainParsingResult.Success(p, value) 29 | 30 | case (p, f: Parsed.Failure) => 31 | DomainParsingResult.Failure(p, s"Failed to parse domain $p: ${f.trace().msg}") 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/il/ast/typed/TypeDef.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.il.ast.typed 2 | 3 | import izumi.idealingua.model.common.TypeId._ 4 | import izumi.idealingua.model.common._ 5 | 6 | sealed trait TypeDef { 7 | def id: TypeId 8 | 9 | def meta: NodeMeta 10 | } 11 | 12 | case class EnumMember(value: String, meta: NodeMeta) 13 | 14 | object TypeDef { 15 | 16 | final case class Alias(id: AliasId, target: TypeId, meta: NodeMeta) extends TypeDef 17 | 18 | final case class Enumeration(id: EnumId, members: List[EnumMember], meta: NodeMeta) extends TypeDef 19 | 20 | final case class Adt(id: AdtId, alternatives: List[AdtMember], meta: NodeMeta) extends TypeDef 21 | 22 | final case class Identifier(id: IdentifierId, fields: IdTuple, meta: NodeMeta) extends TypeDef 23 | 24 | sealed trait WithStructure extends TypeDef { 25 | def id: StructureId 26 | 27 | def struct: Structure 28 | } 29 | 30 | final case class Interface(id: InterfaceId, struct: Structure, meta: NodeMeta) extends WithStructure 31 | 32 | final case class DTO(id: DTOId, struct: Structure, meta: NodeMeta) extends WithStructure 33 | 34 | // final case class ForeignType(id: IndefiniteId, mapping: Map[String, String], meta: NodeMeta) extends TypeDef 35 | 36 | } 37 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Dispatcher.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | using System.Collections; 4 | using System.Collections.Generic; 5 | 6 | namespace IRT { 7 | public class Dispatcher { 8 | private Dictionary> services; 9 | 10 | public Dispatcher() { 11 | services = new Dictionary>(); 12 | } 13 | 14 | public bool Register(IServiceDispatcher dispatcher) { 15 | var svc = dispatcher.GetSupportedService(); 16 | if (services.ContainsKey(svc)) { 17 | return false; 18 | } 19 | 20 | services.Add(svc, dispatcher); 21 | return true; 22 | } 23 | 24 | public bool Unregister(string serviceName) { 25 | return services.Remove(serviceName); 26 | } 27 | 28 | public D Dispatch(C ctx, string service, string method, D data) { 29 | if (!services.ContainsKey(service)) { 30 | throw new DispatcherException(string.Format("Service {0} is not registered with the dispatcher.", service)); 31 | } 32 | 33 | return services[service].Dispatch(ctx, method, data); 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/test/scala/izumi/idealingua/runtime/rpc/http4s/fixtures/LoggingWsListener.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.rpc.http4s.fixtures 2 | 3 | import izumi.functional.bio.{F, IO2} 4 | import izumi.idealingua.runtime.rpc.http4s.ws.{WsSessionId, WsSessionListener} 5 | 6 | import scala.collection.mutable 7 | 8 | final class LoggingWsListener[F[+_, +_]: IO2, RequestCtx, WsCtx] extends WsSessionListener[F, RequestCtx, WsCtx] { 9 | private val connections = mutable.Set.empty[(WsSessionId, WsCtx)] 10 | def connected: Set[(WsSessionId, WsCtx)] = connections.toSet 11 | def connectedContexts: Set[WsCtx] = connections.map(_._2).toSet 12 | 13 | override def onSessionOpened(sessionId: WsSessionId, reqCtx: RequestCtx, wsCtx: WsCtx): F[Throwable, Unit] = F.sync { 14 | connections.add(sessionId -> wsCtx) 15 | }.void 16 | 17 | override def onSessionUpdated(sessionId: WsSessionId, reqCtx: RequestCtx, prevStx: WsCtx, newCtx: WsCtx): F[Throwable, Unit] = F.sync { 18 | connections.remove(sessionId -> prevStx) 19 | connections.add(sessionId -> newCtx) 20 | }.void 21 | 22 | override def onSessionClosed(sessionId: WsSessionId, wsCtx: WsCtx): F[Throwable, Unit] = F.sync { 23 | connections.remove(sessionId -> wsCtx) 24 | }.void 25 | } 26 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/verification/rules/BasicNamingConventionsRule.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.verification.rules 2 | 3 | import izumi.idealingua.model.problems.{IDLDiagnostics, TypespaceError} 4 | import izumi.idealingua.model.typespace.Typespace 5 | import izumi.idealingua.model.typespace.verification.VerificationRule 6 | 7 | object BasicNamingConventionsRule extends VerificationRule { 8 | final val badNames = Set("Iz", "IRT", "IDL") 9 | 10 | override def verify(ts: Typespace): IDLDiagnostics = IDLDiagnostics { 11 | ts.domain.types.flatMap { 12 | t => 13 | val singleChar = if (t.id.name.size < 2) { 14 | Seq(TypespaceError.ShortName(t.id)) 15 | } else { 16 | Seq.empty 17 | } 18 | 19 | val noncapitalized = if (t.id.name.head.isLower) { 20 | Seq(TypespaceError.NoncapitalizedTypename(t.id)) 21 | } else { 22 | Seq.empty 23 | } 24 | 25 | val reserved = if (badNames.exists(t.id.name.startsWith)) { 26 | Seq(TypespaceError.ReservedTypenamePrefix(t.id, badNames)) 27 | } else { 28 | Seq.empty 29 | } 30 | 31 | singleChar ++ 32 | noncapitalized ++ 33 | reserved 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/model/typespace/verification/rules/DuplicateMemberRule.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.model.typespace.verification.rules 2 | 3 | import izumi.idealingua.model.problems.{IDLDiagnostics, TypespaceError} 4 | import izumi.idealingua.model.il.ast.typed.TypeDef.{Adt, Enumeration} 5 | import izumi.idealingua.model.typespace.Typespace 6 | import izumi.idealingua.model.typespace.verification.VerificationRule 7 | 8 | object DuplicateMemberRule extends VerificationRule { 9 | override def verify(ts: Typespace): IDLDiagnostics = IDLDiagnostics { 10 | ts.domain.types.flatMap { 11 | case t: Enumeration => 12 | val duplicates = t.members.groupBy(v => v).filter(_._2.lengthCompare(1) > 0) 13 | if (duplicates.nonEmpty) { 14 | Seq(TypespaceError.DuplicateEnumElements(t.id, duplicates.keys.map(_.value).toList)) 15 | } else { 16 | Seq.empty 17 | } 18 | 19 | case t: Adt => 20 | val duplicates = t.alternatives.groupBy(v => v.typename).filter(_._2.lengthCompare(1) > 0) 21 | if (duplicates.nonEmpty) { 22 | Seq(TypespaceError.DuplicateAdtElements(t.id, duplicates.keys.toList)) 23 | } else { 24 | Seq.empty 25 | } 26 | 27 | case _ => 28 | Seq.empty 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-test-defs/src/main/scala/izumi/r2/idealingua/test/GreeterRunnerExample.scala: -------------------------------------------------------------------------------- 1 | package izumi.r2.idealingua.test 2 | 3 | import _root_.io.circe.syntax.* 4 | import izumi.idealingua.runtime.rpc.{IRTOutputMiddleware, IRTServerMultiplexor} 5 | import izumi.r2.idealingua.test.generated.GreeterServiceServerWrapped 6 | import zio.* 7 | 8 | object GreeterRunnerExample { 9 | def main(args: Array[String]): Unit = { 10 | val greeter = new GreeterServiceServerWrapped[IO, Unit](new impls.AbstractGreeterServer.Impl[IO, Unit]()) 11 | val multiplexor = new IRTServerMultiplexor.FromServices[IO, Unit](Set(greeter), IRTOutputMiddleware.empty) 12 | 13 | val req1 = new greeter.greet.signature.Input("John", "Doe") 14 | val json1 = req1.asJson 15 | println(json1) 16 | 17 | val req2 = new greeter.alternative.signature.Input() 18 | val json2 = req2.asJson 19 | println(json2) 20 | 21 | val invoked1 = multiplexor.invokeMethod(greeter.greet.signature.id)((), json1) 22 | val invoked2 = multiplexor.invokeMethod(greeter.alternative.signature.id)((), json1) 23 | 24 | implicit val unsafe: Unsafe = Unsafe.unsafe(identity) 25 | println(zio.Runtime.default.unsafe.run(invoked1).getOrThrowFiberFailure()) 26 | println(zio.Runtime.default.unsafe.run(invoked2).getOrThrowFiberFailure()) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/renderer/RTypeId.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.renderer 2 | 3 | import izumi.functional.Renderable 4 | import izumi.idealingua.model.common 5 | import izumi.idealingua.model.common._ 6 | 7 | class RTypeId(context: IDLRenderingContext) extends Renderable[TypeId] { 8 | 9 | override def render(value: TypeId): String = { 10 | value match { 11 | case g: Generic => 12 | s"${renderTypeName(g.path, g.name)}${g.args.map(render).mkString("[", ", ", "]")}" 13 | 14 | case t => 15 | renderTypeName(t.path, t.name) 16 | } 17 | } 18 | 19 | private def renderTypeName(pkg: TypePath, name: TypeName) = { 20 | pkg.domain match { 21 | case DomainId.Builtin => 22 | name 23 | 24 | case _ => 25 | Seq(renderPkg(pkg.toPackage), name).filterNot(_.isEmpty).mkString("#") 26 | } 27 | } 28 | 29 | private def renderPkg(value: common.Package): String = { 30 | minimize(value).mkString(".") 31 | } 32 | 33 | private def minimize(value: common.Package): common.Package = { 34 | val domainPkg = context.domain.id.toPackage 35 | if (value == domainPkg) { 36 | Seq.empty 37 | } else if (value.nonEmpty && domainPkg.last == value.head) { 38 | value.tail 39 | } else { 40 | value 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/toscala/types/runtime/Import.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.toscala.types.runtime 2 | 3 | import scala.reflect._ 4 | 5 | trait Import { 6 | def render: String 7 | } 8 | 9 | object Import { 10 | 11 | case class AllPackage(pkg: Pkg) extends Import { 12 | override def render: String = { 13 | val parts = "_root_" +: pkg.pkgParts :+ "_" 14 | s"import ${parts.mkString(".")}" 15 | } 16 | } 17 | 18 | case class PackageMembers(pkg: Pkg, members: (String, Option[String])*) extends Import { 19 | override def render: String = { 20 | val end = if (members.size == 1 && members.head._2.isEmpty) { 21 | members.head._1 22 | } else { 23 | members.map { 24 | case (m, None) => m 25 | case (m, Some(n)) => s"$m => $n" 26 | } 27 | .mkString("{ ", ", ", " }") 28 | } 29 | 30 | val parts = "_root_" +: pkg.pkgParts :+ end 31 | s"import ${parts.mkString(".")}" 32 | } 33 | } 34 | 35 | def from(pkg: Pkg, symbol: String, name: Option[String] = None): Import = { 36 | PackageMembers(pkg, symbol -> name) 37 | } 38 | 39 | def apply[T: ClassTag](name: Option[String] = None): Import = { 40 | from(Pkg.of[T], classTag[T].runtimeClass.getSimpleName, name) 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/transport/transport.websocket.ts: -------------------------------------------------------------------------------- 1 | 2 | export enum WebSocketMessageKind { 3 | Failure = '?:failure', 4 | RpcRequest = 'rpc:request', 5 | RpcResponse = 'rpc:response', 6 | RpcFailure = 'rpc:failure', 7 | BuzzerRequest = 'buzzer:request', 8 | BuzzerResponse = 'buzzer:response', 9 | BuzzerFailure = 'buzzer:failure', 10 | StreamS2C = 'stream:s2c', 11 | StreamC2S = 'stream:c2s' 12 | } 13 | 14 | export interface WebSocketMessageBase { 15 | kind: WebSocketMessageKind 16 | } 17 | 18 | // Matches WebSocketMessageKind.RpcRequest, WebSocketMessageKind.BuzzerRequest 19 | export interface WebSocketRequestMessage extends WebSocketMessageBase { 20 | service?: string 21 | method?: string 22 | id: string 23 | data?: any 24 | headers?: {[key: string]: string} 25 | } 26 | 27 | // Matches WebSocketMessageKind.RpcResponse, WebSocketMessageKind.RpcFailure, 28 | // WebSocketMessageKind.BuzzerResponse, WebSocketMessageKind.BuzzerFailure 29 | export interface WebSocketResponseMessage extends WebSocketMessageBase { 30 | ref: string; 31 | data: any; 32 | } 33 | 34 | // Matches WebSocketMessageKind.Failure 35 | export interface WebSocketFailureMessage extends WebSocketMessageBase { 36 | data: string; 37 | cause: string; 38 | } 39 | -------------------------------------------------------------------------------- /project/plugins.sbt: -------------------------------------------------------------------------------- 1 | // DO NOT EDIT THIS FILE 2 | // IT IS AUTOGENERATED BY `sbtgen.sc` SCRIPT 3 | // ALL CHANGES WILL BE LOST 4 | // https://www.scala-js.org/ 5 | addSbtPlugin("org.scala-js" % "sbt-scalajs" % PV.scala_js_version) 6 | 7 | // https://github.com/portable-scala/sbt-crossproject 8 | addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.3.2") 9 | 10 | // https://scalacenter.github.io/scalajs-bundler/ 11 | addSbtPlugin("ch.epfl.scala" % "sbt-scalajs-bundler" % "0.21.1") 12 | 13 | // https://github.com/scala-js/jsdependencies 14 | addSbtPlugin("org.scala-js" % "sbt-jsdependencies" % "1.0.2") 15 | 16 | //////////////////////////////////////////////////////////////////////////////// 17 | 18 | addSbtPlugin("io.7mind.izumi.sbt" % "sbt-izumi" % "0.0.107") 19 | 20 | addSbtPlugin("com.github.sbt" % "sbt-pgp" % PV.sbt_pgp) 21 | 22 | addSbtPlugin("org.scoverage" % "sbt-scoverage" % PV.sbt_scoverage) 23 | 24 | addSbtPlugin("io.7mind.izumi" % "sbt-izumi-deps" % PV.izumi) 25 | 26 | addSbtPlugin("com.github.sbt" % "sbt-native-packager" % PV.packager) 27 | 28 | // Ignore scala-xml version conflict between scoverage where `coursier` requires scala-xml v2 29 | // and scoverage requires scala-xml v1 on Scala 2.12, 30 | // introduced when updating scoverage from 1.9.3 to 2.0.5 31 | libraryDependencySchemes += "org.scala-lang.modules" %% "scala-xml" % VersionScheme.Always 32 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-csharp/src/main/resources/runtime/csharp/IRT/Transport/WebSocketMessageBase.cs: -------------------------------------------------------------------------------- 1 | 2 | using System; 3 | // using Newtonsoft.Json; 4 | // using Newtonsoft.Json.Linq; 5 | 6 | namespace IRT.Transport { 7 | // [JsonConverter(typeof(WebSocketMessageBase_JsonNetConverter))] 8 | public class WebSocketMessageBase { 9 | public string Kind; 10 | public WebSocketMessageBase(string kind = null) { 11 | Kind = kind; 12 | } 13 | } 14 | 15 | // public class WebSocketMessageBase_JsonNetConverter: JsonNetConverter { 16 | // public override void WriteJson(JsonWriter writer, WebSocketMessageBase holder, JsonSerializer serializer) { 17 | // throw new Exception("WebSocketMessageBase should never be serialized."); 18 | // } 19 | // 20 | // public override WebSocketMessageBase ReadJson(JsonReader reader, System.Type objectType, WebSocketMessageBase existingValue, bool hasExistingValue, JsonSerializer serializer) { 21 | // var json = JObject.Load(reader); 22 | // var kind = json["kind"].Value(); 23 | // 24 | // var res = hasExistingValue ? existingValue : new WebSocketMessageBase(kind); 25 | // res.Kind = kind; 26 | // return res; 27 | // } 28 | // } 29 | } 30 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/DefStreams.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.il.parser 2 | 3 | import izumi.idealingua.il.parser.structure.{kw, sep} 4 | import izumi.idealingua.model.common.StreamDirection 5 | import izumi.idealingua.model.il.ast.raw.defns.{RawStream, RawStreams, RawTopLevelDefn} 6 | import fastparse.NoWhitespace._ 7 | import fastparse._ 8 | 9 | class DefStreams(context: IDLParserContext) { 10 | 11 | import context._ 12 | import sep._ 13 | 14 | def downstream[$: P]: P[RawStream.Directed] = metaAgg.withMeta(defSignature.baseSignature(kw.downstream)).map { 15 | case (meta, (id, in)) => 16 | RawStream.Directed(id, StreamDirection.ToClient, in, meta) 17 | } 18 | 19 | def upstream[$: P]: P[RawStream.Directed] = metaAgg.withMeta(defSignature.baseSignature(kw.upstream)).map { 20 | case (meta, (id, in)) => 21 | RawStream.Directed(id, StreamDirection.ToServer, in, meta) 22 | } 23 | 24 | def stream[$: P]: P[RawStream.Directed] = downstream | upstream 25 | 26 | // other method kinds should be added here 27 | def streams[$: P]: P[Seq[RawStream]] = P(stream.rep(sep = any)) 28 | 29 | def streamsBlock[$: P]: P[RawTopLevelDefn.TLDStreams] = P(metaAgg.cblock(kw.streams, streams)).map { 30 | case (c, i, v) => RawStreams(i.toStreamsId, v.toList, c) 31 | } 32 | .map(RawTopLevelDefn.TLDStreams.apply) 33 | } 34 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-scala/src/main/scala-3/IRTWithCirce.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.circe 2 | 3 | import io.circe.Codec 4 | 5 | /** 6 | * Provides circe codecs for case classes and sealed traits 7 | * 8 | * {{{ 9 | * final case class Abc(a: String, b: String, c: String) 10 | * 11 | * object Abc extends IRTWithCirce[Abc] 12 | * }}} 13 | * 14 | * To derive codecs for a sealed trait with branches inside its 15 | * own companion object, use a proxy object - this works around 16 | * a scala limitation: https://github.com/milessabin/shapeless/issues/837 17 | * 18 | * {{{ 19 | * sealed trait Abc 20 | * 21 | * private abcCodecs extends IRTWithCirce[Abc] 22 | * 23 | * object Abc extends IRTWithCirce(abcCodecs) { 24 | * final case class A() 25 | * object A extends IRTWithCirce[A] 26 | * 27 | * final case class B() 28 | * object B extends IRTWithCirce[B] 29 | * final case class C() 30 | * 31 | * object C extends IRTWithCirce[C] 32 | * } 33 | * }}} 34 | */ 35 | abstract class IRTWithCirce[A]()(implicit derivedCodec: => DerivationDerivedCodec[A]) { 36 | // workaround for https://github.com/milessabin/shapeless/issues/837 37 | def this(proxy: IRTWithCirce[A]) = this()(DerivationDerivedCodec(proxy.codec)) 38 | 39 | implicit lazy val codec: Codec.AsObject[A] = derivedCodec.value 40 | } 41 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-model/src/main/scala/izumi/idealingua/runtime/model/IDLIdentifier.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.runtime.model 2 | 3 | import java.util.UUID 4 | 5 | trait IDLIdentifier extends Any { 6 | this: IDLGeneratedType => 7 | } 8 | 9 | object IDLIdentifier { 10 | def escape(s: String): String = Escaping.escape(s) 11 | 12 | def unescape(s: String): String = Escaping.unescape(s) 13 | 14 | def parsePart[T](v: String, clazz: Class[T]): T = { 15 | val ret = clazz match { 16 | case c if c.isAssignableFrom(classOf[String]) => 17 | v 18 | case c if c.isAssignableFrom(classOf[Boolean]) => 19 | v.toBoolean 20 | case c if c.isAssignableFrom(classOf[Byte]) => 21 | v.toByte 22 | case c if c.isAssignableFrom(classOf[Short]) => 23 | v.toShort 24 | case c if c.isAssignableFrom(classOf[Int]) => 25 | v.toInt 26 | case c if c.isAssignableFrom(classOf[Long]) => 27 | v.toLong 28 | case c if c.isAssignableFrom(classOf[Float]) => 29 | v.toFloat 30 | case c if c.isAssignableFrom(classOf[Double]) => 31 | v.toDouble 32 | case c if c.isAssignableFrom(classOf[UUID]) => 33 | UUID.fromString(v) 34 | case t => 35 | throw new IllegalArgumentException(s"Not supported by identifiers (yet?..): $v: $t => $clazz") 36 | } 37 | ret.asInstanceOf[T] 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-runtime-rpc-typescript/src/main/resources/runtime/typescript/irt/dispatcher.ts: -------------------------------------------------------------------------------- 1 | 2 | export interface ServiceDispatcher { 3 | dispatch(context: C, method: string, data: D | undefined): Promise; 4 | getSupportedService(): string; 5 | getSupportedMethods(): string[]; 6 | } 7 | 8 | export class Dispatcher { 9 | private services: {[key: string]: ServiceDispatcher}; 10 | constructor() { 11 | this.services = {}; 12 | } 13 | 14 | public register(dispatcher: ServiceDispatcher): boolean { 15 | const svc = dispatcher.getSupportedService(); 16 | if (svc in this.services) { 17 | return false; 18 | } 19 | 20 | this.services[svc] = dispatcher; 21 | return true; 22 | } 23 | 24 | public unregister(serviceName: string): boolean { 25 | if (!(serviceName in this.services)) { 26 | return false; 27 | } 28 | 29 | delete this.services[serviceName]; 30 | return true; 31 | } 32 | 33 | public dispatch(ctx: C, service: string, method: string, data: D | undefined): Promise { 34 | if (!(service in this.services)) { 35 | throw new Error(`Service '${service}' is not registered with the dispatcher.`); 36 | } 37 | 38 | return this.services[service].dispatch(ctx, method, data); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /idealingua-v1/idealingua-v1-transpilers/src/main/scala/izumi/idealingua/translator/totypescript/extensions/EnumHelpersExtension.scala: -------------------------------------------------------------------------------- 1 | package izumi.idealingua.translator.totypescript.extensions 2 | 3 | import izumi.fundamentals.platform.strings.IzString._ 4 | import izumi.idealingua.model.il.ast.typed.TypeDef 5 | import izumi.idealingua.translator.totypescript.TSTContext 6 | import izumi.idealingua.translator.totypescript.products.CogenProduct.EnumProduct 7 | 8 | object EnumHelpersExtension extends TypeScriptTranslatorExtension { 9 | override def handleEnum(ctx: TSTContext, enumeration: TypeDef.Enumeration, product: EnumProduct): EnumProduct = { 10 | val it = enumeration.members.map(_.value).iterator 11 | val values = it.map { 12 | m => 13 | s"${enumeration.id.name}.$m" + (if (it.hasNext) "," else "") 14 | }.mkString("\n") 15 | 16 | val extension = 17 | s""" 18 | |export class ${enumeration.id.name}Helpers { 19 | | public static readonly all = [ 20 | |${values.shift(8)} 21 | | ]; 22 | | 23 | | public static isValid(value: string): boolean { 24 | | return ${enumeration.id.name}Helpers.all.indexOf(value as ${enumeration.id.name}) >= 0; 25 | | } 26 | |} 27 | """.stripMargin 28 | 29 | EnumProduct(product.content + extension, product.preamble) 30 | } 31 | } 32 | --------------------------------------------------------------------------------