feat: connect to spicedb

3 files changed, 604 insertions, 0 deletions

diff --git a/vendor/github.com/jzelinskie/stringz/LICENSE b/vendor/github.com/jzelinskie/stringz/LICENSE
new file mode 100644
index 0000000..9c8e20a
--- /dev/null
+++ b/vendor/github.com/jzelinskie/stringz/LICENSE
@@ -0,0 +1,191 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2013-2017 Docker, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/github.com/jzelinskie/stringz/README.md b/vendor/github.com/jzelinskie/stringz/README.md
new file mode 100644
index 0000000..befa226
--- /dev/null
+++ b/vendor/github.com/jzelinskie/stringz/README.md
@@ -0,0 +1,7 @@
+# stringz
+
+[![Go Report Card](https://goreportcard.com/badge/github.com/jzelinskie/stringz?style=flat-square)](https://goreportcard.com/report/github.com/jzelinskie/stringz)
+[![Godoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](https://godoc.org/github.com/jzelinskie/stringz)
+[![LICENSE](https://img.shields.io/github/license/jzelinskie/stringz.svg?style=flat-square)](https://github.com/jzelinskie/stringz/blob/master/LICENSE)
+
+Package stringz provides string manipulations not found in the standard library.
diff --git a/vendor/github.com/jzelinskie/stringz/stringz.go b/vendor/github.com/jzelinskie/stringz/stringz.go
new file mode 100644
index 0000000..be3cffd
--- /dev/null
+++ b/vendor/github.com/jzelinskie/stringz/stringz.go
@@ -0,0 +1,406 @@
+// Copyright 2019 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package stringz implements a collection of utility functions for
+// manipulating strings and lists of strings.
+package stringz
+
+import (
+	"errors"
+	"strings"
+)
+
+// ErrInconsistentUnpackLen is returned when Unpack is provided two slices
+// without the same length.
+var ErrInconsistentUnpackLen = errors.New("the length of the unpacked is not equal to the provided input")
+
+// SliceContains returns true if the provided string is in the provided string
+// slice.
+func SliceContains(ys []string, x string) bool {
+	for _, y := range ys {
+		if x == y {
+			return true
+		}
+	}
+	return false
+}
+
+// SliceIndex returns the index of the first instance of x in ys, or -1 if it
+// is not present.
+func SliceIndex(ys []string, x string) int {
+	for i, y := range ys {
+		if x == y {
+			return i
+		}
+	}
+	return -1
+}
+
+// Dedup returns a new slice with any duplicates removed.
+func Dedup(xs []string) []string {
+	set := make(map[string]struct{}, 0)
+	ys := make([]string, 0, len(xs))
+	for _, x := range xs {
+		if _, alreadyExists := set[x]; alreadyExists {
+			continue
+		}
+		ys = append(ys, x)
+		set[x] = struct{}{}
+	}
+
+	return ys
+}
+
+// DefaultEmpty returns the fallback when val is empty string.
+//
+// This function is inspired by Python's `dict.get()`.
+func DefaultEmpty(val, fallback string) string {
+	return Default(val, fallback, "")
+}
+
+// Default returns a fallback value when the provided value is equal to any
+// of the zero values.
+func Default(val, fallback string, zeroValues ...string) string {
+	for _, zeroValue := range zeroValues {
+		if val == zeroValue {
+			return fallback
+		}
+	}
+
+	return val
+}
+
+// SliceEqual returns true if two string slices are the same.
+// This function is sensitive to order.
+func SliceEqual(xs, ys []string) bool {
+	if len(xs) != len(ys) {
+		return false
+	}
+
+	for i, x := range xs {
+		if x != ys[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// MatrixEqual returns true if two [][]string are equal.
+// This function is sensitive to order.
+func MatrixEqual(xs, ys [][]string) bool {
+	if len(xs) != len(ys) {
+		return false
+	}
+
+	for i, x := range xs {
+		if !SliceEqual(x, ys[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// TrimPrefixIndex trims everything before the provided index.
+func TrimPrefixIndex(s, index string) string {
+	i := strings.Index(s, index)
+	if i <= 0 {
+		return s
+	}
+	return s[i+len(index):]
+}
+
+// TrimSurrounding returns a string with both a prefix and suffix trimmed from
+// it.
+//
+// Do not confuse this with strings.Trim() which removes characters in a cutset
+// rather than working on prefixes and suffixes.
+func TrimSurrounding(s, surrounding string) string {
+	s = strings.TrimPrefix(s, surrounding)
+	return strings.TrimSuffix(s, surrounding)
+}
+
+// SliceMap is a functional-style mapping function for slices of strings.
+//
+// This is particularly useful when you would normally use a for-loop, but want
+// `defer` to execute for each iteration.
+func SliceMap(xs []string, fn func(string) error) error {
+	for _, x := range xs {
+		err := fn(x)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Join is strings.Join, but variadic.
+func Join(prefix string, xs ...string) string { return strings.Join(xs, prefix) }
+
+// CopyStringMap returns a new copy of a map of strings.
+func CopyStringMap(xs map[string]string) map[string]string {
+	// Zero allocation path.
+	if xs == nil {
+		return nil
+	}
+
+	ys := make(map[string]string, len(xs))
+	for k, v := range xs {
+		ys[k] = v
+	}
+	return ys
+}
+
+// Unpack assigns a slice into local variables.
+func Unpack(xs []string, vars ...*string) error {
+	if len(xs) != len(vars) {
+		return ErrInconsistentUnpackLen
+	}
+	for i, x := range xs {
+		*vars[i] = x
+	}
+	return nil
+}
+
+// SplitExact splits the string `s` into `len(vars)` number of strings and
+// unpacks them into those vars.
+//
+// Returns ErrInconsistentUnpackLen if len(vars) doesn't match the number of
+// split segments.
+func SplitExact(s, sep string, vars ...*string) error {
+	exploded := strings.Split(s, sep)
+	return Unpack(exploded, vars...)
+}
+
+// SplitInto splits the string `s` into `len(vars)` number of strings and
+// unpacks them into those vars. If there are more substrings that would be
+// split after len(vars), they will be all be put into the final variable.
+//
+// Returns ErrInconsistentUnpackLen if len(vars) is greater than the number
+// of split substrings.
+func SplitInto(s, sep string, vars ...*string) error {
+	exploded := strings.SplitN(s, sep, len(vars))
+	return Unpack(exploded, vars...)
+}
+
+// SlicePermutations returns all permutations of a string slice.
+//
+// It is equivalent to `SliceCombinationsR(xs, len(xs))`.
+func SlicePermutations(xs []string) [][]string {
+	return SlicePermutationsR(xs, len(xs))
+}
+
+// SlicePermutationsR returns successive r-length permutations of elements in
+// the provided string slice.
+//
+// If r is less than 0 or larger than the length of the pool, nil is returned.
+//
+// The permutation tuples are emitted in lexicographic ordering according to
+// the order of the input iterable. So, if the input iterable is sorted, the
+// combination tuples will be produced in sorted order.
+//
+// Elements are treated as unique based on their position, not on their value.
+// So if the input elements are unique, there will be no repeat values in each
+// permutation.
+//
+// This is the algorithm used in Python's itertools library:
+// itertools.permutations(iterable, r=None)
+func SlicePermutationsR(pool []string, r int) [][]string {
+	if r <= 0 || pool == nil || r > len(pool) {
+		return nil
+	}
+	n := len(pool)
+
+	indices := make([]int, n)
+	for i := range pool {
+		indices[i] = i
+	}
+
+	var ys [][]string
+
+	{
+		var y []string
+		for _, i := range indices[:r] {
+			y = append(y, pool[i])
+		}
+		ys = append(ys, y)
+	}
+
+	cycles := make([]int, n-(n-r))
+	for i := range cycles {
+		cycles[i] = n - i
+	}
+
+	for {
+		broke := false
+
+		for i := r - 1; i >= 0; i-- {
+			cycles[i] = cycles[i] - 1
+			if cycles[i] == 0 {
+				indices = append(indices[:i], append(indices[i+1:], indices[i:i+1]...)...)
+				cycles[i] = n - i
+			} else {
+				j := cycles[i]
+				indices[i], indices[len(indices)-j] = indices[len(indices)-j], indices[i]
+
+				var y []string
+				for _, i := range indices[:r] {
+					y = append(y, pool[i])
+				}
+				ys = append(ys, y)
+
+				broke = true
+				break
+			}
+		}
+		if !broke {
+			return ys
+		}
+	}
+}
+
+// SliceCombinationsR returns r-length subsequences of elements from the
+// provided string slice.
+//
+// If r is less than 0 or larger than the length of the pool, nil is returned.
+//
+// The combinations are emitted in lexicographic ordering according to the
+// order of the input iterable. So, if the input iterable is sorted, the
+// combination tuples will be produced in sorted order.
+//
+// Elements are treated as unique based on their position, not on their value.
+// So if the input elements are unique, there will be no repeat values in each
+// combination.
+//
+// This is the algorithm used in Python's itertools library:
+// itertools.combinations(iterable, r)
+func SliceCombinationsR(pool []string, r int) [][]string {
+	if r <= 0 || pool == nil || r > len(pool) {
+		return nil
+	}
+	n := len(pool)
+
+	indices := make([]int, r)
+	for i := range indices {
+		indices[i] = i
+	}
+
+	var ys [][]string
+
+	{
+		var y []string
+		for _, j := range indices {
+			y = append(y, pool[j])
+		}
+		ys = append(ys, y)
+	}
+
+	for {
+		var i int
+		broke := false
+		for i = r - 1; i >= 0; i-- {
+			if indices[i] != i+n-r {
+				broke = true
+				break
+			}
+		}
+		if !broke {
+			return ys
+		}
+
+		indices[i] = indices[i] + 1
+		for j := i + 1; j < r; j++ {
+			indices[j] = indices[j-1] + 1
+		}
+
+		var y []string
+		for _, j := range indices {
+			y = append(y, pool[j])
+		}
+		ys = append(ys, y)
+	}
+}
+
+// SliceCombinationsWithReplacement returns r-length subsequences of elements
+// from the provided string slice allowing individual elements to be repeated
+// more than once.
+//
+// If r is less than 0 or larger than the length of the pool, nil is returned.
+//
+// The combination tuples are emitted in lexicographic ordering according to
+// the order of the input iterable. So, if the input iterable is sorted, the
+// combination tuples will be produced in sorted order.
+//
+// Elements are treated as unique based on their position, not on their value.
+// So if the input elements are unique, the generated combinations will also be
+// unique.
+//
+// This is the algorithm used in Python's itertools library:
+// itertools.combinations_with_replacement(iterable, r)
+func SliceCombinationsWithReplacement(pool []string, r int) [][]string {
+	if r <= 0 || pool == nil || r > len(pool) {
+		return nil
+	}
+	n := len(pool)
+
+	indices := make([]int, r)
+	var ys [][]string
+
+	{
+		var y []string
+		for _, j := range indices {
+			y = append(y, pool[j])
+		}
+		ys = append(ys, y)
+	}
+
+	for {
+		var i int
+		broke := false
+		for i = r - 1; i >= 0; i-- {
+			if indices[i] != n-1 {
+				broke = true
+				break
+			}
+		}
+		if !broke {
+			return ys
+		}
+
+		newIndices := make([]int, r-i)
+		for j := range newIndices {
+			newIndices[j] = indices[i] + 1
+		}
+		indices = append(indices[:i], newIndices...)
+
+		var y []string
+		for _, j := range indices {
+			y = append(y, pool[j])
+		}
+		ys = append(ys, y)
+	}
+}
+
+// LastCut slices s around the last instance of sep,
+// returning the text before and after sep.
+//
+// The found result reports whether sep appears in s.
+// If sep does not appear in s, LastCut returns s, "", false.
+func LastCut(s, sep string) (before, after string, found bool) {
+	if i := strings.LastIndex(s, sep); i >= 0 {
+		return s[:i], s[i+len(sep):], true
+	}
+	return s, "", false
+}