wip: feat: add scalar kind

[no ci]

Signed-off-by: Justin Chadwell <[email protected]>

cmd/codegen/generator/go/templates/module_types.go

@@ -69,6 +69,7 @@ func (ps *parseState) parseGoTypeReference(typ types.Type, named *types.Named, i
  }
  parsedType := &parsedPrimitiveType{goType: t, isPtr: isPtr}
  if named != nil {
+ parsedType.aliasType = named
  parsedType.alias = named.Obj().Name()
  }
  return parsedType, nil
@@ -121,7 +122,8 @@ type parsedPrimitiveType struct {
  isPtr bool
 
  // if this is something like `type Foo string`, then alias will be "Foo"
- alias string
+ alias string
+ aliasType *types.Named
 }
 
 var _ ParsedType = &parsedPrimitiveType{}
@@ -144,6 +146,10 @@ func (spec *parsedPrimitiveType) TypeDefCode() (*Statement, error) {
  if spec.isPtr {
  def = def.Dot("WithOptional").Call(Lit(true))
  }
+ if spec.alias != "" {
+ // XXX: should replace WithKind
+ def = def.Dot("WithScalar").Call(Lit(spec.alias))
+ }
  return def, nil
 }
 
@@ -152,6 +158,9 @@ func (spec *parsedPrimitiveType) GoType() types.Type {
 }
 
 func (spec *parsedPrimitiveType) GoSubTypes() []types.Type {
+ if spec.aliasType != nil {
+ return []types.Type{spec.aliasType}
+ }
  return nil
 }
 

cmd/codegen/generator/go/templates/modules.go

@@ -151,6 +151,24 @@ func (funcs goTemplateFuncs) moduleMainSrc() (string, error) { //nolint: gocyclo
  }
 
  switch underlyingObj := named.Underlying().(type) {
+ case *types.Basic:
+ if ps.isDaggerGenerated(obj) {
+ break
+ }
+
+ typeSpec, err := ps.parseGoTypeReference(underlyingObj, named, false)
+ if err != nil {
+ return "", err
+ }
+
+ // Add the scalar to the module
+ scalarTypeDefCode, err := typeSpec.TypeDefCode()
+ if err != nil {
+ return "", fmt.Errorf("failed to generate type def code for %s: %w", obj.Name(), err)
+ }
+ createMod = dotLine(createMod, "WithScalar").Call(Add(Line(), scalarTypeDefCode))
+ added[obj.Name()] = struct{}{}
+
  case *types.Struct:
  strct := underlyingObj
  objTypeSpec, err := ps.parseGoStruct(strct, named)

cmd/dagger/flags.go

@@ -615,6 +615,17 @@ func (r *modFunctionArg) AddFlag(flags *pflag.FlagSet, dag *dagger.Client) (any,
  val, _ := getDefaultValue[bool](r)
  return flags.Bool(name, val, usage), nil
 
+ case dagger.ScalarKind:
+ scalarName := r.TypeDef.AsScalar.Name
+
+ if val := GetCustomFlagValue(scalarName); val != nil {
+ flags.Var(val, name, usage)
+ return val, nil
+ }
+
+ val, _ := getDefaultValue[string](r)
+ return flags.String(name, val, usage), nil
+
  case dagger.ObjectKind:
  objName := r.TypeDef.AsObject.Name
 
@@ -653,6 +664,17 @@ func (r *modFunctionArg) AddFlag(flags *pflag.FlagSet, dag *dagger.Client) (any,
  val, _ := getDefaultValue[[]bool](r)
  return flags.BoolSlice(name, val, usage), nil
 
+ case dagger.ScalarKind:
+ scalarName := r.TypeDef.AsScalar.Name
+
+ if val := GetCustomFlagValueSlice(scalarName); val != nil {
+ flags.Var(val, name, usage)
+ return val, nil
+ }
+
+ val, _ := getDefaultValue[[]string](r)
+ return flags.StringSlice(name, val, usage), nil
+
  case dagger.ObjectKind:
  objName := elementType.AsObject.Name
 

cmd/dagger/module.go

@@ -744,27 +744,30 @@ fragment TypeDefRefParts on TypeDef {
  kind
  optional
  asObject {
-  name
+ name
  }
  asInterface {
-  name
+ name
  }
  asInput {
-  name
+ name
  }
  asList {
- elementTypeDef {
- kind
- asObject {
- name
- }
- asInterface {
- name
- }
- asInput {
- name
- }
+ elementTypeDef {
+ kind
+ asObject {
+ name
+ }
+ asInterface {
+ name
+ }
+ asInput {
+ name
  }
+ }
+ }
+ asScalar {
+ name
  }
 }
 
@@ -809,6 +812,9 @@ query TypeDefs {
  ...FieldParts
  }
  }
+ asScalar {
+ name
+ }
  asInterface {
  name
  sourceModuleName
@@ -843,6 +849,8 @@ query TypeDefs {
  modDef := &moduleDef{Name: name}
  for _, typeDef := range res.TypeDefs {
  switch typeDef.Kind {
+ case dagger.ScalarKind:
+ modDef.Scalars = append(modDef.Scalars, typeDef)
  case dagger.ObjectKind:
  modDef.Objects = append(modDef.Objects, typeDef)
  case dagger.InterfaceKind:
@@ -857,6 +865,7 @@ query TypeDefs {
 // moduleDef is a representation of dagger.Module.
 type moduleDef struct {
  Name string
+ Scalars []*modTypeDef
  Objects []*modTypeDef
  Interfaces []*modTypeDef
  Inputs []*modTypeDef
@@ -987,6 +996,7 @@ type modTypeDef struct {
  AsInterface *modInterface
  AsInput *modInput
  AsList *modList
+ AsScalar *modScalar
 }
 
 type functionProvider interface {
@@ -1089,6 +1099,10 @@ func (o *modInterface) GetFunction(name string) (*modFunction, error) {
  return nil, fmt.Errorf("no function '%s' in interface type '%s'", name, o.Name)
 }
 
+type modScalar struct {
+ Name string
+}
+
 type modInput struct {
  Name string
  Fields []*modField

core/modtypes.go

@@ -30,6 +30,7 @@ type ModType interface {
 // PrimitiveType are the basic types like string, int, bool, void, etc.
 type PrimitiveType struct {
  Def *TypeDef
+ Mod *Module // XXX: no this is the wrong place for it
 }
 
 func (t *PrimitiveType) ConvertFromSDKResult(ctx context.Context, value any) (dagql.Typed, error) {
@@ -42,7 +43,10 @@ func (t *PrimitiveType) ConvertToSDKInput(ctx context.Context, value dagql.Typed
 }
 
 func (t *PrimitiveType) SourceMod() Mod {
- return nil
+ if t.Mod == nil {
+ return nil
+ }
+ return t.Mod
 }
 
 func (t *PrimitiveType) TypeDef() *TypeDef {

core/module.go

@@ -58,6 +58,9 @@ type Module struct {
  // The module's interfaces
  InterfaceDefs []*TypeDef `field:"true" name:"interfaces" doc:"Interfaces served by this module."`
 
+ // The module's scalars
+ ScalarDefs []*TypeDef `field:"true" name:"scalars" doc:"Scalars served by this module."`
+
  // InstanceID is the ID of the initialized module.
  InstanceID *call.ID
 }
@@ -161,6 +164,12 @@ func (mod *Module) Initialize(ctx context.Context, oldSelf dagql.Instance[*Modul
  return nil, fmt.Errorf("failed to add interface to module %q: %w", mod.Name(), err)
  }
  }
+ for _, scalar := range inst.Self.ScalarDefs {
+ newMod, err = newMod.WithScalar(ctx, scalar)
+ if err != nil {
+ return nil, fmt.Errorf("failed to add scalar to module %q: %w", mod.Name(), err)
+ }
+ }
  newMod.InstanceID = newID
 
  return newMod, nil
@@ -215,6 +224,17 @@ func (mod *Module) Install(ctx context.Context, dag *dagql.Server) error {
  }
  }
 
+ for _, def := range mod.ScalarDefs {
+ scalarDef := def.AsScalar.Value
+
+ slog.ExtraDebug("installing scalar", "name", mod.Name(), "scalar", scalarDef.Name)
+
+ s := dagql.NewScalar(scalarDef.Name, scalarDef.Description)
+ dag.InstallScalar(s)
+
+ return nil
+ }
+
  return nil
 }
 
@@ -234,6 +254,13 @@ func (mod *Module) TypeDefs(ctx context.Context) ([]*TypeDef, error) {
  }
  typeDefs = append(typeDefs, typeDef)
  }
+ for _, def := range mod.ScalarDefs {
+ typeDef := def.Clone()
+ if typeDef.AsScalar.Valid {
+ typeDef.AsScalar.Value.SourceModuleName = mod.Name()
+ }
+ typeDefs = append(typeDefs, typeDef)
+ }
  return typeDefs, nil
 }
 
@@ -245,7 +272,7 @@ func (mod *Module) ModTypeFor(ctx context.Context, typeDef *TypeDef, checkDirect
  var modType ModType
  switch typeDef.Kind {
  case TypeDefKindString, TypeDefKindInteger, TypeDefKindBoolean, TypeDefKindVoid:
- modType = &PrimitiveType{typeDef}
+ modType = &PrimitiveType{typeDef, nil}
 
  case TypeDefKindList:
  underlyingType, ok, err := mod.ModTypeFor(ctx, typeDef.AsList.Value.ElementTypeDef, checkDirectDeps)
@@ -260,6 +287,32 @@ func (mod *Module) ModTypeFor(ctx context.Context, typeDef *TypeDef, checkDirect
  Underlying: underlyingType,
  }
 
+ case TypeDefKindScalar:
+ if checkDirectDeps {
+ // check to see if this is from a *direct* dependency
+ depType, ok, err := mod.Deps.ModTypeFor(ctx, typeDef)
+ if err != nil {
+ return nil, false, fmt.Errorf("failed to get type from dependency: %w", err)
+ }
+ if ok {
+ return depType, true, nil
+ }
+ }
+
+ var found bool
+ // otherwise it must be from this module
+ for _, obj := range mod.ScalarDefs {
+ if obj.AsScalar.Value.Name == typeDef.AsScalar.Value.Name {
+ modType = &PrimitiveType{typeDef, mod}
+ found = true
+ break
+ }
+ }
+ if !found {
+ slog.ExtraDebug("module did not find scalar", "mod", mod.Name(), "scalar", typeDef.AsScalar.Value.Name)
+ return nil, false, nil
+ }
+
  case TypeDefKindObject:
  if checkDirectDeps {
  // check to see if this is from a *direct* dependency
@@ -470,6 +523,17 @@ func (mod *Module) namespaceTypeDef(ctx context.Context, typeDef *TypeDef) error
  if err := mod.namespaceTypeDef(ctx, typeDef.AsList.Value.ElementTypeDef); err != nil {
  return err
  }
+
+ case TypeDefKindScalar:
+ scalar := typeDef.AsScalar.Value
+ _, ok, err := mod.Deps.ModTypeFor(ctx, typeDef)
+ if err != nil {
+ return fmt.Errorf("failed to get mod type for type def: %w", err)
+ }
+ if !ok {
+ scalar.Name = namespaceObject(scalar.OriginalName, mod.Name(), mod.OriginalName)
+ }
+
  case TypeDefKindObject:
  obj := typeDef.AsObject.Value
 
@@ -499,6 +563,7 @@ func (mod *Module) namespaceTypeDef(ctx context.Context, typeDef *TypeDef) error
  }
  }
  }
+
  case TypeDefKindInterface:
  iface := typeDef.AsInterface.Value
 
@@ -629,6 +694,11 @@ func (mod Module) Clone() *Module {
  cp.InterfaceDefs[i] = def.Clone()
  }
 
+ cp.ScalarDefs = make([]*TypeDef, len(mod.ScalarDefs))
+ for i, def := range mod.ScalarDefs {
+ cp.ScalarDefs[i] = def.Clone()
+ }
+
  return &cp
 }
 
@@ -688,6 +758,32 @@ func (mod *Module) WithInterface(ctx context.Context, def *TypeDef) (*Module, er
  return mod, nil
 }
 
+func (mod *Module) WithScalar(ctx context.Context, def *TypeDef) (*Module, error) {
+ mod = mod.Clone()
+ if !def.AsScalar.Valid {
+ return nil, fmt.Errorf("expected scalar def, got %s: %+v", def.Kind, def)
+ }
+
+ // skip validation+namespacing for module objects being constructed by SDK with* calls
+ // they will be validated when merged into the real final module
+
+ // XXX: aha do this bit!
+ if mod.Deps != nil {
+ if err := mod.validateTypeDef(ctx, def); err != nil {
+ return nil, fmt.Errorf("failed to validate type def: %w", err)
+ }
+ }
+ if mod.NameField != "" {
+ def = def.Clone()
+ if err := mod.namespaceTypeDef(ctx, def); err != nil {
+ return nil, fmt.Errorf("failed to namespace type def: %w", err)
+ }
+ }
+
+ mod.ScalarDefs = append(mod.ScalarDefs, def)
+ return mod, nil
+}
+
 type CurrentModule struct {
  Module *Module
 }