Skip to content

Commit 7c8a39e

Browse files
mgomesmgomes
committed
split database capability adapter internals
1 parent 5577430 commit 7c8a39e

3 files changed

Lines changed: 220 additions & 227 deletions

File tree

‎vibes/capability_db.go‎

Lines changed: 0 additions & 227 deletions
Original file line numberDiff line numberDiff line change
@@ -72,230 +72,3 @@ type dbCapability struct {
7272
name string
7373
db Database
7474
}
75-
76-
func (c *dbCapability) CapabilityContracts() map[string]CapabilityMethodContract {
77-
return map[string]CapabilityMethodContract{
78-
c.name + ".find": {
79-
ValidateArgs: c.validateFindContractArgs,
80-
ValidateReturn: c.validateMethodReturn(c.name + ".find"),
81-
},
82-
c.name + ".query": {
83-
ValidateArgs: c.validateQueryContractArgs,
84-
ValidateReturn: c.validateMethodReturn(c.name + ".query"),
85-
},
86-
c.name + ".update": {
87-
ValidateArgs: c.validateUpdateContractArgs,
88-
ValidateReturn: c.validateMethodReturn(c.name + ".update"),
89-
},
90-
c.name + ".sum": {
91-
ValidateArgs: c.validateSumContractArgs,
92-
ValidateReturn: c.validateMethodReturn(c.name + ".sum"),
93-
},
94-
c.name + ".each": {
95-
ValidateArgs: c.validateEachContractArgs,
96-
ValidateReturn: c.validateMethodReturn(c.name + ".each"),
97-
},
98-
}
99-
}
100-
101-
func (c *dbCapability) Bind(binding CapabilityBinding) (map[string]Value, error) {
102-
methods := map[string]Value{
103-
"find": NewBuiltin(c.name+".find", c.callFind),
104-
"query": NewBuiltin(c.name+".query", c.callQuery),
105-
"update": NewBuiltin(c.name+".update", c.callUpdate),
106-
"sum": NewBuiltin(c.name+".sum", c.callSum),
107-
"each": NewBuiltin(c.name+".each", c.callEach),
108-
}
109-
return map[string]Value{c.name: NewObject(methods)}, nil
110-
}
111-
112-
func (c *dbCapability) callFind(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
113-
if err := c.validateFindContractArgs(args, kwargs, block); err != nil {
114-
return NewNil(), err
115-
}
116-
collection, _ := capabilityNameArg(c.name+".find", "collection", args[0])
117-
req := DBFindRequest{
118-
Collection: collection,
119-
ID: deepCloneValue(args[1]),
120-
Options: cloneCapabilityKwargs(kwargs),
121-
}
122-
result, err := c.db.Find(exec.ctx, req)
123-
if err != nil {
124-
return NewNil(), err
125-
}
126-
return c.cloneMethodResult(c.name+".find", result)
127-
}
128-
129-
func (c *dbCapability) callQuery(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
130-
if err := c.validateQueryContractArgs(args, kwargs, block); err != nil {
131-
return NewNil(), err
132-
}
133-
collection, _ := capabilityNameArg(c.name+".query", "collection", args[0])
134-
req := DBQueryRequest{
135-
Collection: collection,
136-
Options: cloneCapabilityKwargs(kwargs),
137-
}
138-
result, err := c.db.Query(exec.ctx, req)
139-
if err != nil {
140-
return NewNil(), err
141-
}
142-
return c.cloneMethodResult(c.name+".query", result)
143-
}
144-
145-
func (c *dbCapability) callUpdate(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
146-
if err := c.validateUpdateContractArgs(args, kwargs, block); err != nil {
147-
return NewNil(), err
148-
}
149-
collection, _ := capabilityNameArg(c.name+".update", "collection", args[0])
150-
req := DBUpdateRequest{
151-
Collection: collection,
152-
ID: deepCloneValue(args[1]),
153-
Attributes: cloneHash(args[2].Hash()),
154-
Options: cloneCapabilityKwargs(kwargs),
155-
}
156-
result, err := c.db.Update(exec.ctx, req)
157-
if err != nil {
158-
return NewNil(), err
159-
}
160-
return c.cloneMethodResult(c.name+".update", result)
161-
}
162-
163-
func (c *dbCapability) callSum(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
164-
if err := c.validateSumContractArgs(args, kwargs, block); err != nil {
165-
return NewNil(), err
166-
}
167-
collection, _ := capabilityNameArg(c.name+".sum", "collection", args[0])
168-
field, _ := capabilityNameArg(c.name+".sum", "field", args[1])
169-
req := DBSumRequest{
170-
Collection: collection,
171-
Field: field,
172-
Options: cloneCapabilityKwargs(kwargs),
173-
}
174-
result, err := c.db.Sum(exec.ctx, req)
175-
if err != nil {
176-
return NewNil(), err
177-
}
178-
return c.cloneMethodResult(c.name+".sum", result)
179-
}
180-
181-
func (c *dbCapability) callEach(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
182-
if err := c.validateEachContractArgs(args, kwargs, block); err != nil {
183-
return NewNil(), err
184-
}
185-
collection, _ := capabilityNameArg(c.name+".each", "collection", args[0])
186-
req := DBEachRequest{
187-
Collection: collection,
188-
Options: cloneCapabilityKwargs(kwargs),
189-
}
190-
rows, err := c.db.Each(exec.ctx, req)
191-
if err != nil {
192-
return NewNil(), err
193-
}
194-
for idx, row := range rows {
195-
if err := exec.step(); err != nil {
196-
return NewNil(), err
197-
}
198-
if err := validateCapabilityTypedValue(fmt.Sprintf("%s.each row %d", c.name, idx), row, capabilityTypeAny); err != nil {
199-
return NewNil(), err
200-
}
201-
if _, err := exec.CallBlock(block, []Value{deepCloneValue(row)}); err != nil {
202-
return NewNil(), err
203-
}
204-
}
205-
return NewNil(), nil
206-
}
207-
208-
func (c *dbCapability) validateFindContractArgs(args []Value, kwargs map[string]Value, block Value) error {
209-
method := c.name + ".find"
210-
if len(args) != 2 {
211-
return fmt.Errorf("%s expects collection and id", method)
212-
}
213-
if !block.IsNil() {
214-
return fmt.Errorf("%s does not accept blocks", method)
215-
}
216-
if _, err := capabilityNameArg(method, "collection", args[0]); err != nil {
217-
return err
218-
}
219-
if err := validateCapabilityTypedValue(method+" id", args[1], capabilityTypeAny); err != nil {
220-
return err
221-
}
222-
return validateCapabilityKwargsDataOnly(method, kwargs)
223-
}
224-
225-
func (c *dbCapability) validateQueryContractArgs(args []Value, kwargs map[string]Value, block Value) error {
226-
method := c.name + ".query"
227-
if len(args) != 1 {
228-
return fmt.Errorf("%s expects collection", method)
229-
}
230-
if !block.IsNil() {
231-
return fmt.Errorf("%s does not accept blocks", method)
232-
}
233-
if _, err := capabilityNameArg(method, "collection", args[0]); err != nil {
234-
return err
235-
}
236-
return validateCapabilityKwargsDataOnly(method, kwargs)
237-
}
238-
239-
func (c *dbCapability) validateUpdateContractArgs(args []Value, kwargs map[string]Value, block Value) error {
240-
method := c.name + ".update"
241-
if len(args) != 3 {
242-
return fmt.Errorf("%s expects collection, id, and attributes", method)
243-
}
244-
if !block.IsNil() {
245-
return fmt.Errorf("%s does not accept blocks", method)
246-
}
247-
if _, err := capabilityNameArg(method, "collection", args[0]); err != nil {
248-
return err
249-
}
250-
if err := validateCapabilityTypedValue(method+" id", args[1], capabilityTypeAny); err != nil {
251-
return err
252-
}
253-
if err := validateCapabilityHashValue(method+" attributes", args[2]); err != nil {
254-
return err
255-
}
256-
return validateCapabilityKwargsDataOnly(method, kwargs)
257-
}
258-
259-
func (c *dbCapability) validateSumContractArgs(args []Value, kwargs map[string]Value, block Value) error {
260-
method := c.name + ".sum"
261-
if len(args) != 2 {
262-
return fmt.Errorf("%s expects collection and field", method)
263-
}
264-
if !block.IsNil() {
265-
return fmt.Errorf("%s does not accept blocks", method)
266-
}
267-
if _, err := capabilityNameArg(method, "collection", args[0]); err != nil {
268-
return err
269-
}
270-
if _, err := capabilityNameArg(method, "field", args[1]); err != nil {
271-
return err
272-
}
273-
return validateCapabilityKwargsDataOnly(method, kwargs)
274-
}
275-
276-
func (c *dbCapability) validateEachContractArgs(args []Value, kwargs map[string]Value, block Value) error {
277-
method := c.name + ".each"
278-
if len(args) != 1 {
279-
return fmt.Errorf("%s expects collection", method)
280-
}
281-
if err := ensureBlock(block, method); err != nil {
282-
return err
283-
}
284-
if _, err := capabilityNameArg(method, "collection", args[0]); err != nil {
285-
return err
286-
}
287-
return validateCapabilityKwargsDataOnly(method, kwargs)
288-
}
289-
290-
func (c *dbCapability) validateMethodReturn(method string) func(result Value) error {
291-
return func(result Value) error {
292-
return validateCapabilityTypedValue(method+" return value", result, capabilityTypeAny)
293-
}
294-
}
295-
296-
func (c *dbCapability) cloneMethodResult(method string, result Value) (Value, error) {
297-
if err := validateCapabilityTypedValue(method+" return value", result, capabilityTypeAny); err != nil {
298-
return NewNil(), err
299-
}
300-
return deepCloneValue(result), nil
301-
}

‎vibes/capability_db_calls.go‎

Lines changed: 110 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,110 @@
1+
package vibes
2+
3+
import "fmt"
4+
5+
func (c *dbCapability) Bind(binding CapabilityBinding) (map[string]Value, error) {
6+
methods := map[string]Value{
7+
"find": NewBuiltin(c.name+".find", c.callFind),
8+
"query": NewBuiltin(c.name+".query", c.callQuery),
9+
"update": NewBuiltin(c.name+".update", c.callUpdate),
10+
"sum": NewBuiltin(c.name+".sum", c.callSum),
11+
"each": NewBuiltin(c.name+".each", c.callEach),
12+
}
13+
return map[string]Value{c.name: NewObject(methods)}, nil
14+
}
15+
16+
func (c *dbCapability) callFind(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
17+
if err := c.validateFindContractArgs(args, kwargs, block); err != nil {
18+
return NewNil(), err
19+
}
20+
collection, _ := capabilityNameArg(c.name+".find", "collection", args[0])
21+
req := DBFindRequest{
22+
Collection: collection,
23+
ID: deepCloneValue(args[1]),
24+
Options: cloneCapabilityKwargs(kwargs),
25+
}
26+
result, err := c.db.Find(exec.ctx, req)
27+
if err != nil {
28+
return NewNil(), err
29+
}
30+
return cloneCapabilityMethodResult(c.name+".find", result)
31+
}
32+
33+
func (c *dbCapability) callQuery(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
34+
if err := c.validateQueryContractArgs(args, kwargs, block); err != nil {
35+
return NewNil(), err
36+
}
37+
collection, _ := capabilityNameArg(c.name+".query", "collection", args[0])
38+
req := DBQueryRequest{
39+
Collection: collection,
40+
Options: cloneCapabilityKwargs(kwargs),
41+
}
42+
result, err := c.db.Query(exec.ctx, req)
43+
if err != nil {
44+
return NewNil(), err
45+
}
46+
return cloneCapabilityMethodResult(c.name+".query", result)
47+
}
48+
49+
func (c *dbCapability) callUpdate(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
50+
if err := c.validateUpdateContractArgs(args, kwargs, block); err != nil {
51+
return NewNil(), err
52+
}
53+
collection, _ := capabilityNameArg(c.name+".update", "collection", args[0])
54+
req := DBUpdateRequest{
55+
Collection: collection,
56+
ID: deepCloneValue(args[1]),
57+
Attributes: cloneHash(args[2].Hash()),
58+
Options: cloneCapabilityKwargs(kwargs),
59+
}
60+
result, err := c.db.Update(exec.ctx, req)
61+
if err != nil {
62+
return NewNil(), err
63+
}
64+
return cloneCapabilityMethodResult(c.name+".update", result)
65+
}
66+
67+
func (c *dbCapability) callSum(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
68+
if err := c.validateSumContractArgs(args, kwargs, block); err != nil {
69+
return NewNil(), err
70+
}
71+
collection, _ := capabilityNameArg(c.name+".sum", "collection", args[0])
72+
field, _ := capabilityNameArg(c.name+".sum", "field", args[1])
73+
req := DBSumRequest{
74+
Collection: collection,
75+
Field: field,
76+
Options: cloneCapabilityKwargs(kwargs),
77+
}
78+
result, err := c.db.Sum(exec.ctx, req)
79+
if err != nil {
80+
return NewNil(), err
81+
}
82+
return cloneCapabilityMethodResult(c.name+".sum", result)
83+
}
84+
85+
func (c *dbCapability) callEach(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
86+
if err := c.validateEachContractArgs(args, kwargs, block); err != nil {
87+
return NewNil(), err
88+
}
89+
collection, _ := capabilityNameArg(c.name+".each", "collection", args[0])
90+
req := DBEachRequest{
91+
Collection: collection,
92+
Options: cloneCapabilityKwargs(kwargs),
93+
}
94+
rows, err := c.db.Each(exec.ctx, req)
95+
if err != nil {
96+
return NewNil(), err
97+
}
98+
for idx, row := range rows {
99+
if err := exec.step(); err != nil {
100+
return NewNil(), err
101+
}
102+
if err := validateCapabilityTypedValue(fmt.Sprintf("%s.each row %d", c.name, idx), row, capabilityTypeAny); err != nil {
103+
return NewNil(), err
104+
}
105+
if _, err := exec.CallBlock(block, []Value{deepCloneValue(row)}); err != nil {
106+
return NewNil(), err
107+
}
108+
}
109+
return NewNil(), nil
110+
}

0 commit comments

Comments
 (0)